gofannon 0.1.0__py3-none-any.whl

gofannon/orchestration/__init__.py

@@ -0,0 +1,144 @@
+import json
+import time
+from typing import List, Dict, Any
+from ..base import WorkflowContext, ToolResult
+from ..config import FunctionRegistry
+import logging
+
+logger = logging.getLogger(__name__)
+
+class FunctionOrchestrator:
+    def __init__(self, llm_client, tool_configs=None):
+        self.logger = logging.getLogger(f"{__name__}.FunctionOrchestrator")
+        self.llm = llm_client
+        self.available_functions = FunctionRegistry.get_tools()
+        self.tool_configs = tool_configs or {}
+        self.function_map = self.function_map = self._build_function_map()
+        self.logger.debug("Available functions in orchestrator: " + ', '.join(
+            [f['function']['name'] for f in self.available_functions]))
+
+    def _build_function_map(self):
+        return {
+            func_def['function']['name']: (
+                FunctionRegistry._tools[func_def['function']['name']],
+                self.tool_configs.get(func_def['function']['name'], {})
+            ) for func_def in self.available_functions
+        }
+
+    def _instantiate_tool(self, function_name):
+        tool_class, config = self.function_map[function_name]
+        return tool_class(**config)
+
+    def execute_workflow(self, user_query: str, model_name: str, max_steps=5):
+        self.logger.debug("Starting workflow execution with query: %s", user_query)
+        messages = [{"role": "user", "content": user_query}]
+        final_answer = None
+
+        for _ in range(max_steps):
+            # Get LLM response
+            response = self.llm.chat.completions.create(
+                model=model_name,
+                messages=messages,
+                tools=self.available_functions
+            )
+            msg = response.choices[0].message
+            messages.append(msg)
+
+            # Check for direct answer first
+            if msg.content and not msg.tool_calls:
+                final_answer = msg.content
+                break
+
+                # Process tool calls if any
+            if msg.tool_calls:
+                for tool_call in msg.tool_calls:
+                    function_name = tool_call.function.name
+
+                    function_args = json.loads(tool_call.function.arguments)
+
+                    # Execute function
+                    # Get tool class and configuration
+                    tool_class, config = self.function_map[function_name]
+
+                    # Instantiate tool with configuration
+                    tool = tool_class(**config)
+
+                    # Execute function
+                    result = tool.fn(**function_args)
+
+                    # Store result in context
+                    messages.append({
+                        "role": "tool",
+                        "tool_call_id": tool_call.id,
+                        "content": str(result),#.output,
+                        # "name": function_name
+                    })
+            else:
+                break  # Exit if no tools called and no content
+
+        # Final synthesis step
+        if not final_answer:
+            synthesis_prompt = '''Based on the tool outputs above,   
+            provide a complete natural language answer with final numerical result   
+            in bold. Follow this format:  
+              
+            **Final Answer**: [result in bold]   
+              
+            With supporting calculations shown.'''
+
+            messages.append({"role": "user", "content": synthesis_prompt})
+
+            response = self.llm.chat.completions.create(
+                model=model_name,
+                messages=messages
+            )
+            final_answer = response.choices[0].message.content
+
+        return {
+            "conversation": messages,
+            "final_answer": final_answer
+        }
+
+class ToolChain:
+    def __init__(self, tools: List[Any], context: WorkflowContext):
+        self.tools = tools
+        self.context = context
+
+    def _resolve_input(self, input_template: str) -> Any:
+        if not input_template:
+            return None
+
+        if input_template.startswith('{{') and input_template.endswith('}}'):
+            key = input_template[2:-2].strip()
+            return self.context.data.get(key)
+        return input_template
+
+    def execute(self, initial_input: Dict[str, Any] = None) -> ToolResult:
+        self.context.data.update(initial_input or {})
+
+        for tool in self.tools:
+            tool_name = tool.__class__.__name__
+
+            # Resolve inputs from context
+            resolved_inputs = {
+                k: self._resolve_input(v)
+                for k, v in tool.definition.get('function', {}).get('parameters', {}).items()
+            }
+
+            # Execute tool
+            result = tool.execute(self.context, **resolved_inputs)
+
+            if not result.success:
+                return result
+
+                # Store output in context
+            output_key = f"{tool_name}_output"
+            self.context.data[output_key] = result.output
+
+            # Save checkpoint
+            self.context.save_checkpoint(f"after_{tool_name}")
+
+        return ToolResult(
+            success=True,
+            output=self.context.data
+        )

gofannon/orchestration/firebase_wrapper.py

@@ -0,0 +1,42 @@
+import firebase_admin
+from firebase_admin import credentials, firestore
+from typing import Optional
+from . import WorkflowContext
+
+class FirebaseWrapper:
+    _initialized = False
+
+    @classmethod
+    def initialize(cls, config_path: Optional[str] = None):
+        if not cls._initialized:
+            if config_path:
+                cred = credentials.Certificate(config_path)
+            else:
+                cred = credentials.ApplicationDefault()
+
+            firebase_admin.initialize_app(cred)
+            cls._initialized = True
+
+    @classmethod
+    def get_context(cls, doc_id: str) -> WorkflowContext:
+        db = firestore.client()
+        doc_ref = db.collection('workflows').document(doc_id)
+        doc = doc_ref.get()
+
+        if doc.exists:
+            data = doc.to_dict()
+            context = WorkflowContext(firebase_config=True)
+            context.data = data.get('data', {})
+            context.execution_log = data.get('execution_log', [])
+            return context
+        return WorkflowContext(firebase_config=True)
+
+    @classmethod
+    def save_context(cls, doc_id: str, context: WorkflowContext):
+        db = firestore.client()
+        doc_ref = db.collection('workflows').document(doc_id)
+        doc_ref.set({
+            'data': context.data,
+            'execution_log': context.execution_log,
+            'timestamp': firestore.SERVER_TIMESTAMP
+        })

gofannon/reasoning/__init__.py

@@ -0,0 +1,3 @@
+from .sequential_cot import SequentialCoT
+from .hierarchical_cot import HierarchicalCoT
+from .tree_of_thought import TreeOfThought

gofannon/reasoning/base.py

@@ -0,0 +1,47 @@
+from abc import ABC, abstractmethod
+import json
+from openai import OpenAI
+from gofannon.base import BaseTool
+
+sample_depth_chart = [
+    {'model_name' : "Qwen/Qwen2.5-72B-Instruct",
+     'base_url' : "https://api.deepinfra.com/v1/openai",
+     'api_key' : "YOUR_API_KEY_HERE",
+     'temperature' : 0.3,
+     'prompt_appendix' : '\n\nThinks carefully.'
+     }
+]
+
+class ReasoningTool(BaseTool, ABC):
+    def __init__(self,
+                 depth_chart = sample_depth_chart
+                 ):
+        super().__init__()
+        self.depth_chart = depth_chart
+        self.error_context = []
+        self.jsonify_prompt_s = "Your output should be a properly formatted JSON only. No preamble, explanations, or markdown ticks (```)."
+
+
+    @abstractmethod
+    def fn(self, *args, **kwargs):
+        pass
+
+    def create_openai_like_client(self, level: int):
+        return OpenAI(
+            api_key=self.depth_chart[level]['api_key'],
+            base_url=self.depth_chart[level]['base_url']
+        )
+
+    def get_response(self, level: int, messages):
+        return self.create_openai_like_client(level).chat.completions.create(
+            model=self.depth_chart[level]['model_name'],
+            messages=messages,
+            temperature=self.depth_chart[level]['temperature']
+        )
+
+    def get_debug_info(self):
+        """Get current debugging information"""
+        return {
+            "error_context": self.error_context,
+            "depth_chart_config": self.depth_chart
+        }

gofannon/reasoning/hierarchical_cot.py

@@ -0,0 +1,272 @@
+import json
+import logging
+from openai import OpenAI, APIError
+from.base import ReasoningTool
+from ..config import FunctionRegistry
+
+logger = logging.getLogger(__name__)
+
+@FunctionRegistry.register
+class HierarchicalCoT(ReasoningTool):
+    def __init__(self, depth_chart= None):
+        super().__init__(depth_chart=depth_chart)
+        self.name = "hierarchical_cot"
+        self.depth_chart = depth_chart or []
+        self.error_context = []  # Track error locations
+
+    @property
+    def definition(self):
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": "Hierarchical Chain-of-Thought reasoning with outline generation and section expansion",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "prompt": {
+                            "type": "string",
+                            "description": "The problem prompt to process"
+                        },
+                        "depth": {
+                            "type": "integer",
+                            "description": "Depth of hierarchy (default: 2)",
+                            "default": 2
+                        }
+                    },
+                    "required": ["prompt"]
+                }
+            }
+        }
+
+    def fn(self, prompt, depth=2):
+        self.error_context = []  # Reset error tracking
+        if depth > len(self.depth_chart):
+            return {"error": f"Requested depth {depth} exceeds configured model levels {len(self.depth_chart)}"}
+
+        try:
+            if depth < 1:
+                raise ValueError("Depth must be at least 1")
+
+            outline = self._generate_outline(prompt, depth)
+            if 'error' in outline:
+                return outline
+
+            return self._expand_sections(outline, current_depth=1, max_depth=depth)
+
+        except Exception as e:
+            logger.error(f"Critical failure: {str(e)}")
+            return {
+                "error": "HierarchicalCoT processing failed",
+                "context": self.error_context,
+                "exception": str(e)
+            }
+
+    def _generate_outline(self, prompt, depth):
+        try:
+            outline_prompt = f"""Organize this problem into a {depth}-level hierarchical structure:    
+            {prompt}    
+              
+            Your output should be a properly formatted JSON only. No preamble, explanations, or markdown ticks (```).   
+            Return JSON format with keys 'title' and 'sections' (array of section objects).   
+            """
+            if depth > 1:
+                outline_prompt += "Each section should have 'title' and 'sections'. "
+
+            messages = [{"role": "user", "content": outline_prompt}]
+            response = self.get_response(level=0, messages=messages)
+
+            try:
+                structure = json.loads(response.choices[0].message.content)
+            except json.JSONDecodeError as e:
+                self.error_context.append({
+                    "stage": "outline_parsing",
+                    "response": response.choices[0].message.content,
+                    "error": str(e)
+                })
+                return {"error": "Invalid JSON structure in outline"}
+
+                # Validate outline structure
+            if not isinstance(structure, dict):
+                self.error_context.append({
+                    "stage": "outline_validation",
+                    "structure_type": type(structure).__name__,
+                    "expected_type": "dict"
+                })
+                return {"error": "Outline structure is not a dictionary"}
+
+            required_keys = {'title', 'sections'}
+            if not required_keys.issubset(structure.keys()):
+                self.error_context.append({
+                    "stage": "outline_validation",
+                    "missing_keys": list(required_keys - structure.keys())
+                })
+                return {"error": f"Outline missing required keys: {required_keys}"}
+
+            return structure
+
+        except APIError as e:
+            self.error_context.append({
+                "stage": "outline_generation",
+                "error_type": "APIError",
+                "status_code": e.status_code,
+                "message": e.message
+            })
+            return {"error": "API failure during outline generation"}
+
+        except Exception as e:
+            self.error_context.append({
+                "stage": "outline_generation",
+                "error_type": type(e).__name__,
+                "message": str(e)
+            })
+            return {"error": "Unexpected error during outline generation"}
+
+    def _expand_sections(self, node, current_depth, max_depth, path=None):
+        if path is None:
+            path = []
+
+        current_path = path + [node.get('title', 'Untitled Section')]
+
+        if current_depth >= max_depth:
+            return node
+
+        if current_depth >= len(self.depth_chart):
+            self.error_context.append({
+                "stage": "depth_validation",
+                "current_depth": current_depth,
+                "max_configured_depth": len(self.depth_chart)-1
+            })
+            raise ValueError("Current depth exceeds configured model depth chart")
+
+        try:
+            client = self.create_openai_like_client(current_depth)
+            expanded = node.copy()
+
+            if 'sections' in node:
+                for i, section in enumerate(node['sections']):
+                    logger.debug(f"Expanding section {i+1}/{len(node['sections'])} at depth {current_depth}")
+
+                    next_depth = current_depth + 1
+                    is_final_depth = next_depth == max_depth
+
+                    # Generate appropriate prompt based on depth
+                    if is_final_depth:
+                        expansion_prompt = f"""Expand this section within the context of: {" -> ".join(current_path)}    
+                          
+                        Section to expand: {section['title']}      
+                        Current depth: {current_depth}/{max_depth}      
+                          
+                        Provide detailed content for this section. The content should be a concise explanation.  
+                        Your output should be a properly formatted JSON only with a 'content' field.   
+                        No preamble, explanations, or markdown ticks (```). """
+                    else:
+                        expansion_prompt = f"""Expand this section within the context of: {" -> ".join(current_path)}    
+                          
+                        Section to expand: {section['title']}      
+                        Current depth: {current_depth}/{max_depth}      
+                          
+                        Provide detailed sub-sections in JSON format with 'title' and 'sections'.    
+                        Your output should be a properly formatted JSON only. No preamble, explanations, or markdown ticks (```). """
+
+                    try:
+                        response = client.chat.completions.create(
+                            model=self.depth_chart[current_depth]['model_name'],
+                            messages=[{"role": "user", "content": expansion_prompt}],
+                            temperature=self.depth_chart[current_depth]['temperature']
+                        )
+                    except APIError as e:
+                        self.error_context.append({
+                            "stage": f"section_expansion_depth_{current_depth}",
+                            "section_index": i,
+                            "section_title": section.get('title'),
+                            "error_type": "APIError",
+                            "status_code": e.status_code,
+                            "message": e.message
+                        })
+                        continue
+
+                    if not response.choices:
+                        self.error_context.append({
+                            "stage": f"section_expansion_depth_{current_depth}",
+                            "section_index": i,
+                            "error": "Empty API response"
+                        })
+                        continue
+
+                    try:
+                        expanded_section = json.loads(response.choices[0].message.content)
+                    except json.JSONDecodeError as e:
+                        self.error_context.append({
+                            "stage": f"section_parsing_depth_{current_depth}",
+                            "section_index": i,
+                            "response": response.choices[0].message.content,
+                            "error": str(e)
+                        })
+                        continue
+
+                        # Handle content generation for final depth
+                    if is_final_depth:
+                        if 'content' not in expanded_section:
+                            self.error_context.append({
+                                "stage": f"content_validation_depth_{current_depth}",
+                                "section_index": i,
+                                "response": expanded_section
+                            })
+                            continue
+
+                            # Update section with content and remove subsections
+                        expanded['sections'][i]['content'] = expanded_section['content']
+                        if 'sections' in expanded['sections'][i]:
+                            del expanded['sections'][i]['sections']
+                    else:
+                        # Validate section structure and recursively expand
+                        if not isinstance(expanded_section, dict) or 'title' not in expanded_section:
+                            self.error_context.append({
+                                "stage": f"section_validation_depth_{current_depth}",
+                                "section_index": i,
+                                "response_structure": type(expanded_section).__name__
+                            })
+                            continue
+
+                        expanded['sections'][i] = self._expand_sections(
+                            expanded_section,
+                            next_depth,
+                            max_depth,
+                            current_path
+                        )
+
+            return expanded
+
+        except Exception as e:
+            self.error_context.append({
+                "stage": f"section_expansion_depth_{current_depth}",
+                "error_type": type(e).__name__,
+                "message": str(e),
+                "node": node.get('title')[:100] if 'title' in node else str(node)[:100]
+            })
+            raise
+
+    def get_debug_info(self):
+        return {
+            "error_context": self.error_context,
+            "depth_chart_config": self.depth_chart
+        }
+
+    def to_markdown(self, output):
+        def _to_markdown(node, level=1):
+            markdown = ""
+
+            if 'title' in node:
+                title = node['title']
+                markdown += f"{'#' * level} {title}\n\n"
+
+            if 'content' in node:
+                markdown += f"{node['content']}\n\n"
+
+            if 'sections' in node:
+                for section in node['sections']:
+                    markdown += _to_markdown(section, level + 1)
+
+            return markdown
+        return _to_markdown(output)

gofannon/reasoning/sequential_cot.py

@@ -0,0 +1,77 @@
+import json
+from openai import OpenAI
+from gofannon.reasoning.base import ReasoningTool
+from ..config import FunctionRegistry
+import logging
+
+logger = logging.getLogger(__name__)
+
+@FunctionRegistry.register
+class SequentialCoT(ReasoningTool):
+    def __init__(self, depth_chart= None, steps= 5):
+        super().__init__(depth_chart= depth_chart)
+        self.name = "sequential_cot"
+        self.depth_chart = depth_chart or []
+        self.steps = steps
+
+
+    @property
+    def definition(self):
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": "Generate a series of steps required to solve a problem using Chain-of-Thought reasoning.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "prompt": {
+                            "type": "string",
+                            "description": "The prompt to generate steps for."
+                        },
+                        "steps" : {
+                            "type": "number",
+                            "description": "How many steps to take. (Default 3)"
+                        }
+                    },
+                    "required": ["prompt", "steps"]
+                }
+            }
+        }
+
+    def fn(self, prompt, steps):
+        logger.debug(f"Starting SequentialCoT with {steps} steps")
+        modified_prompt = prompt + f"""
+        
+Given the prompt above, return a series of {steps} steps required to arrive at an answer. 
+Do not attempt to compute the answer now, only return the series of steps 
+required to solve the problem, as a series of prompts to future LLM calls. Your 
+response should be a properly formatted json with one field `steps` which contains
+ an array of strings, where each string is a step. Do no include any explanations
+  or ticks to indicate it is a markdown code block."""
+
+        messages = [{"role": "user", "content": modified_prompt}]
+
+        response = self.get_response(level= 0 , messages= messages)
+        messages= [
+            {'role': 'user', 'content': prompt},
+            {'role' : 'assistant', 'content':response.choices[0].message.content}
+        ]
+
+        try:
+            steps = json.loads(response.choices[0].message.content)["steps"]
+            step_output = []
+            for i in range(len(steps)):
+                logger.debug(f"Executing Step {i+1}/{len(steps)}:'{steps[i]}'...")
+                messages.append({'role': 'user', 'content': steps[i]})
+
+                response = self.get_response(level= 1, messages= messages)
+                step_output.append(response.choices[0].message.content)
+                messages.append({'role': 'assistant', 'content': response.choices[0].message.content})
+            messages.append({'role': 'user', 'content': self.depth_chart[2]['prompt_appendix']})
+            logger.debug('Synthesizing Response')
+            response = self.get_response(level = 2, messages= messages)
+            return response
+        except json.JSONDecodeError:
+            return {"error": "Failed to decode the response as JSON."}
+