Agentic task generation

README.md

@@ -87,4 +87,12 @@ python -m src.agentic_capability_generator
 
 # Generate tasks for each capability
 python -m src.agentic_task_generator
+
+# Generate tasks for all capabilities
+python -m src.agentic_task_generator pipeline_tags.capabilities_tag=_20250902_030203
+
+# Generate solutions for tasks using multi-agent debate
+python -m src.agentic_task_solver pipeline_tags.tasks_tag=_20250905_153532
+
+
 ```

pyproject.toml

@@ -18,8 +18,10 @@ dependencies = [
     "langchain>=0.3.19",
     "matplotlib>=3.10.0",
     "omegaconf>=2.3.0",
-    "openai>=1.92.0",
-    "pyautogen>=0.2.22",
+    "openai>=1.102.0",
+    "ag2>=0.3.2",
+    "autogen-ext[openai,anthropic]>=0.7.4",
+    "anthropic>=0.64.0",
     "ratelimit>=2.2.1",
     "torchvision (>=0.21.0,<0.22.0)",
     "torchaudio (>=2.6.0,<3.0.0)",

src/agentic_capability_generator.py

@@ -29,6 +29,7 @@
 def main(cfg: DictConfig) -> None:
     """Run the multi-agent debate-based capability generation system."""
     areas_tag = cfg.pipeline_tags.areas_tag
+    resume_tag = getattr(cfg.pipeline_tags, "resume_capabilities_tag", None)
     domain_name = cfg.global_cfg.domain
     exp_id = cfg.exp_cfg.exp_id
     num_capabilities_per_area = cfg.capability_generation.num_capabilities_per_area
@@ -62,24 +63,32 @@ def main(cfg: DictConfig) -> None:
                 error_msg = "No areas_tag provided. Please provide pipeline_tags.areas_tag=<tag> to specify which areas to use."
                 log.warning(error_msg)
                 span.update(
-                    level="WARNING",
+                    level="ERROR",
                     status_message="Missing areas_tag",
                     metadata={"areas_tag_missing": error_msg},
                 )
                 return
 
+            if resume_tag:
+                msg = f"Resuming capability generation from tag: {resume_tag}"
+                log.info(msg)
+                span.update(
+                    metadata={"resume_tag_found": msg, "resume_tag": resume_tag}
+                )
+
             span.update_trace(
                 metadata={
                     "domain": domain_name,
                     "exp_id": exp_id,
                     "areas_tag": areas_tag,
+                    "resume_tag": resume_tag,
                     "num_capabilities_per_area": num_capabilities_per_area,
                     "config": config_yaml,
                 },
                 tags=["agentic_capability_generation", exp_id],
             )
 
-            asyncio.run(generate_capabilities(cfg, areas_tag, lf))
+            asyncio.run(generate_capabilities(cfg, areas_tag, lf, resume_tag))
 
             msg = (
                 "Multi-agent debate-based capability generation completed successfully"

src/agentic_task_generator.py

@@ -2,39 +2,118 @@
 
 import asyncio
 import logging
+import os
 import traceback
 
 import hydra
+import openlit
+from langfuse import Langfuse
 from omegaconf import DictConfig, OmegaConf
 
-from .task_generation import generate_tasks
+from src.task_generation import generate_tasks
 
 
+# Suppress OpenTelemetry console output
+os.environ["OTEL_LOG_LEVEL"] = "ERROR"
+os.environ["OTEL_METRICS_EXPORTER"] = "none"
+os.environ["OTEL_PYTHON_LOG_CORRELATION"] = "false"
+os.environ["OTEL_PYTHON_LOG_LEVEL"] = "ERROR"
+
 log = logging.getLogger("agentic_task_gen")
 
+lf = Langfuse()
+openlit.init(tracer=lf._otel_tracer, disable_batch=True, disable_metrics=True)
+
 
 @hydra.main(version_base=None, config_path="cfg", config_name="agentic_config")
 def main(cfg: DictConfig) -> None:
     """Run the multi-agent task generation system."""
-    log.info("Starting multi-agent task generation")
-    log.info("Configuration:\n%s", OmegaConf.to_yaml(cfg, resolve=True))
-
-    # Check for capabilities_tag parameter
     capabilities_tag = cfg.pipeline_tags.capabilities_tag
-    if capabilities_tag:
-        log.info(f"Using capabilities from tag: {capabilities_tag}")
-    else:
-        log.warning(
-            "No capabilities_tag provided. Please provide --pipeline_tags.capabilities_tag=<tag> to specify which capabilities to use."
-        )
-        return
-
-    try:
-        asyncio.run(generate_tasks(cfg, capabilities_tag))
-    except Exception as e:
-        log.error(f"Task generation failed: {e}")
-        log.error(f"Full traceback: {traceback.format_exc()}")
-        raise
+    resume_tag = getattr(cfg.pipeline_tags, "resume_tasks_tag", None)
+    domain_name = cfg.global_cfg.domain
+    exp_id = cfg.exp_cfg.exp_id
+
+    with lf.start_as_current_span(
+        name=f"ace_agentic_task_generation:{domain_name}:{exp_id}"
+    ) as span:
+        try:
+            msg = "Starting multi-agent task generation"
+            log.info(msg)
+            span.update(metadata={"system_started": msg})
+
+            config_yaml = OmegaConf.to_yaml(cfg, resolve=True)
+            msg = "Configuration loaded"
+            log.info("Configuration:\n%s", config_yaml)
+            span.update(
+                metadata={
+                    "configuration_loaded": msg,
+                    "config": config_yaml,
+                    "domain": domain_name,
+                    "exp_id": exp_id,
+                }
+            )
+
+            if capabilities_tag:
+                msg = f"Using capabilities from tag: {capabilities_tag}"
+                log.info(msg)
+                span.update(
+                    metadata={
+                        "capabilities_tag_found": msg,
+                        "capabilities_tag": capabilities_tag,
+                    }
+                )
+            else:
+                error_msg = "No capabilities_tag provided. Please provide pipeline_tags.capabilities_tag=<tag> to specify which capabilities to use."
+                log.warning(error_msg)
+                span.update(
+                    level="ERROR",
+                    status_message="Missing capabilities_tag",
+                    metadata={"capabilities_tag_missing": error_msg},
+                )
+                return
+
+            if resume_tag:
+                msg = f"Resuming task generation from tag: {resume_tag}"
+                log.info(msg)
+                span.update(
+                    metadata={"resume_tag_found": msg, "resume_tag": resume_tag}
+                )
+
+            span.update_trace(
+                metadata={
+                    "domain": domain_name,
+                    "exp_id": exp_id,
+                    "capabilities_tag": capabilities_tag,
+                    "resume_tag": resume_tag,
+                    "config": config_yaml,
+                },
+                tags=["agentic_task_generation", exp_id],
+            )
+
+            asyncio.run(generate_tasks(cfg, capabilities_tag, lf, resume_tag))
+
+            msg = "Multi-agent task generation completed successfully"
+            log.info(msg)
+            span.update(metadata={"system_completed": msg})
+
+        except Exception as e:
+            error_msg = f"Task generation failed: {e}"
+            traceback_msg = f"Full traceback: {traceback.format_exc()}"
+
+            log.error(error_msg)
+            log.error(traceback_msg)
+
+            span.update(
+                level="ERROR",
+                status_message=str(e),
+                metadata={
+                    "system_error": error_msg,
+                    "error": str(e),
+                    "traceback": traceback_msg,
+                },
+            )
+
+            raise
 
 
 if __name__ == "__main__":

src/agentic_task_solver.py

@@ -0,0 +1,125 @@
+"""Multi-agent debate system for solving generated tasks."""
+
+import asyncio
+import logging
+import os
+import traceback
+
+import hydra
+import openlit
+from langfuse import Langfuse
+from omegaconf import DictConfig, OmegaConf
+
+from src.task_solver import solve_tasks
+
+
+# Suppress OpenTelemetry console output
+os.environ["OTEL_LOG_LEVEL"] = "ERROR"
+os.environ["OTEL_METRICS_EXPORTER"] = "none"
+os.environ["OTEL_PYTHON_LOG_CORRELATION"] = "false"
+os.environ["OTEL_PYTHON_LOG_LEVEL"] = "ERROR"
+
+log = logging.getLogger("agentic_task_solver")
+
+langfuse_client = Langfuse()
+openlit.init(
+    tracer=langfuse_client._otel_tracer, disable_batch=True, disable_metrics=True
+)
+
+
+@hydra.main(version_base=None, config_path="cfg", config_name="agentic_config")
+def main(cfg: DictConfig) -> None:
+    """Run the multi-agent debate-based task solving system."""
+    tasks_tag = cfg.pipeline_tags.get("tasks_tag")
+    resume_tag = getattr(cfg.pipeline_tags, "resume_solutions_tag", None)
+    domain_name = cfg.global_cfg.domain
+    exp_id = cfg.exp_cfg.exp_id
+
+    with langfuse_client.start_as_current_span(
+        name=f"ace_agentic_task_solver:{domain_name}:{exp_id}"
+    ) as span:
+        try:
+            msg = "Starting multi-agent debate-based task solver"
+            log.info(msg)
+            span.update(metadata={"system_started": msg})
+
+            config_yaml = OmegaConf.to_yaml(cfg, resolve=True)
+            msg = "Configuration loaded"
+            log.info("Configuration:\n%s", config_yaml)
+            span.update(
+                metadata={
+                    "configuration_loaded": msg,
+                    "config": config_yaml,
+                    "domain": domain_name,
+                    "exp_id": exp_id,
+                }
+            )
+
+            if tasks_tag:
+                msg = f"Using tasks from tag: {tasks_tag}"
+                log.info(msg)
+                span.update(
+                    metadata={
+                        "tasks_tag_found": msg,
+                        "tasks_tag": tasks_tag,
+                    }
+                )
+            else:
+                error_msg = "No tasks_tag provided. Please provide pipeline_tags.tasks_tag=<tag> to specify which tasks to solve."
+                log.warning(error_msg)
+                span.update(
+                    level="ERROR",
+                    status_message="Missing tasks_tag",
+                    metadata={"tasks_tag_missing": error_msg},
+                )
+                return
+
+            if resume_tag:
+                msg = f"Resuming task solving from tag: {resume_tag}"
+                log.info(msg)
+                span.update(
+                    metadata={"resume_tag_found": msg, "resume_tag": resume_tag}
+                )
+
+            span.update_trace(
+                metadata={
+                    "domain": domain_name,
+                    "exp_id": exp_id,
+                    "tasks_tag": tasks_tag,
+                    "resume_tag": resume_tag,
+                    "config": config_yaml,
+                },
+                tags=["agentic_task_solver", exp_id],
+            )
+
+            asyncio.run(solve_tasks(cfg, tasks_tag, langfuse_client, resume_tag))
+
+            msg = "Multi-agent debate-based task solving completed successfully"
+            log.info(msg)
+            span.update(metadata={"system_completed": msg})
+
+        except Exception as e:
+            error_msg = f"Task solving failed: {e}"
+            traceback_msg = f"Full traceback: {traceback.format_exc()}"
+
+            log.error(error_msg)
+            log.error(traceback_msg)
+
+            span.update(
+                level="ERROR",
+                status_message=str(e),
+                metadata={
+                    "system_error": error_msg,
+                    "error": str(e),
+                    "traceback": traceback_msg,
+                },
+            )
+
+            raise
+
+        finally:
+            langfuse_client.flush()
+
+
+if __name__ == "__main__":
+    main()