dialectical-framework 1.2.0__tar.gz → 1.2.1__tar.gz

{dialectical_framework-1.2.0 → dialectical_framework-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dialectical-framework
-Version: 1.2.0
+Version: 1.2.1
 Summary: A dialectical framework for augmented intelligence. AI reasoning powered with dialectics supports humans in: system optimization (psychology, engineering, business, politics, etc.); dispute resolution (mediation, conflicts, negotiations, etc.); decision-making (dilemmas, challenging situations, win-win, etc.).
 License: MIT
 Keywords: dialectics,dialectical-reasoning,synthesis,thesis-antithesis,ai,artificial-intelligence,llm,reasoning-framework,philosophy,logic,argumentation,conflict-resolution,decision-making,critical-thinking,semantic-graph,mirascope,pydantic,perspectives,polarity-reasoning

{dialectical_framework-1.2.0 → dialectical_framework-1.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dialectical-framework"
-version = "1.2.0"
+version = "1.2.1"
 description = "A dialectical framework for augmented intelligence. AI reasoning powered with dialectics supports humans in: system optimization (psychology, engineering, business, politics, etc.); dispute resolution (mediation, conflicts, negotiations, etc.); decision-making (dilemmas, challenging situations, win-win, etc.)."
 authors = ["Evaldas Taroza <evaldas@dialexity.com>"]
 readme = "README.md"

{dialectical_framework-1.2.0 → dialectical_framework-1.2.1}/src/dialectical_framework/agents/explorer/explorer.py

@@ -9,6 +9,7 @@ Also contains ExplorationPipeline — the headless pipeline for programmatic use
 
 from __future__ import annotations
 
+import asyncio
 from typing import TYPE_CHECKING, Annotated, AsyncGenerator, Optional
 
 from mirascope import llm
@@ -230,21 +231,27 @@ class ExplorationPipeline(ReasonableConcern[ExplorationResult]):
 
         transformation_count = 0
 
-        for wheel_hash in wheel_hashes:
+        async def _explore_wheel(wheel_hash: str) -> tuple[int, Optional[StepError]]:
             try:
                 explore_tr = ExploreTransformations(wheel_hash=wheel_hash)
                 tr_result = await explore_tr.resolve()
                 reports.append(explore_tr.report)
-                transformation_count += len(tr_result.new)
+                return len(tr_result.new), None
             except Exception as e:
-                errors.append(
-                    StepError(
-                        step="explore_transformations",
-                        message=str(e),
-                        hash=wheel_hash,
-                    )
+                return 0, StepError(
+                    step="explore_transformations",
+                    message=str(e),
+                    hash=wheel_hash,
                 )
 
+        wheel_results = await asyncio.gather(*[
+            _explore_wheel(wh) for wh in wheel_hashes
+        ])
+        for count, error in wheel_results:
+            transformation_count += count
+            if error:
+                errors.append(error)
+
         self._report.ok = True
         self._report.summary = (
             f"Exploration complete: {len(cycle_hashes)} cycles, "

{dialectical_framework-1.2.0 → dialectical_framework-1.2.1}/src/dialectical_framework/agents/explorer/skills/explore_transformations.py

@@ -22,8 +22,10 @@ Usage:
 
 from __future__ import annotations
 
+import asyncio
+import logging
 from dataclasses import dataclass, field
-from typing import Annotated, Optional, TYPE_CHECKING
+from typing import Annotated, Any, Optional, TYPE_CHECKING
 
 from dependency_injector.wiring import Provide, inject
 from mirascope import llm
@@ -116,27 +118,47 @@ class ExploreTransformations(ReasonableConcern[ExploreTransformationsResult]):
         # 3. Get input text from scope
         input_text = await self._get_input_text()
 
-        # 4. Process each edge pair — both edges get Transformations
+        # 4. Process edge pairs in parallel — both edges get Transformations
+        pair_results = await asyncio.gather(
+            *[
+                self._process_edge_pair(wheel, nexus, edge_a, edge_b, input_text)
+                for edge_a, edge_b in edge_pairs
+            ],
+            return_exceptions=True,
+        )
+
         all_existing: list[Transformation] = []
         all_new: list[Transformation] = []
         last_apexes: Optional[ApexDerivationResultDto] = None
 
-        for edge_a, edge_b in edge_pairs:
-            existing, new, apexes = await self._process_edge_pair(
-                wheel, nexus, edge_a, edge_b, input_text
-            )
+        for result in pair_results:
+            if isinstance(result, Exception):
+                logging.getLogger(__name__).warning("Edge pair failed: %s", result)
+                continue
+            existing, new, apexes = result
             all_existing.extend(existing)
             all_new.extend(new)
             if apexes:
                 last_apexes = apexes
 
-        # 5. Audit new transformations for feasibility
+        # 5. Audit new transformations in parallel
         if all_new:
             from dialectical_framework.concerns.transformation_audit import TransformationAudit
-            for tr in all_new:
+
+            async def _audit_one(tr: Transformation) -> TransformationAudit:
                 auditor = TransformationAudit()
                 await auditor.resolve(tr, input_text)
-                self._report = self._report.merge(auditor.report)
+                return auditor
+
+            audit_results = await asyncio.gather(
+                *[_audit_one(tr) for tr in all_new],
+                return_exceptions=True,
+            )
+            for result in audit_results:
+                if isinstance(result, Exception):
+                    logging.getLogger(__name__).warning("Audit failed: %s", result)
+                    continue
+                self._report = self._report.merge(result.report)
 
         # Summary
         self._report.artifacts["wheel_hash"] = wheel.short_hash
@@ -166,8 +188,8 @@ class ExploreTransformations(ReasonableConcern[ExploreTransformationsResult]):
         """
         Process a diametrically opposite edge pair.
 
-        Phase 1: Extract Ac+ candidates for both edges independently.
-        Phase 2: Generate tetrads for each edge, passing the opposite Ac+ for Re-side.
+        Phase 1: Extract Ac+ candidates for both edges in parallel.
+        Phase 2: Generate tetrads for all candidates in parallel.
 
         Returns:
             Tuple of (existing, new, apexes)
@@ -176,11 +198,12 @@ class ExploreTransformations(ReasonableConcern[ExploreTransformationsResult]):
 
         tr_repo = TransformationRepository()
         all_existing: list[Transformation] = []
-        all_new: list[Transformation] = []
         last_apexes: Optional[ApexDerivationResultDto] = None
 
-        # Phase 1: Extract Ac+ for both edges (check existing first)
+        # Phase 1: Extract Ac+ for both edges in parallel (check existing first)
+        phase1_tasks: list[tuple[Transition, asyncio.Task]] = []
         edge_data: dict[str, _EdgeProcessingData] = {}
+
         for edge in (edge_a, edge_b):
             assert edge.hash is not None
             existing = tr_repo.find_by_edge(edge=edge)
@@ -198,43 +221,50 @@ class ExploreTransformations(ReasonableConcern[ExploreTransformationsResult]):
                 edge_data[edge.hash] = _EdgeProcessingData(skip=True)
                 continue
 
-            apex_service = ApexDerivation()
-            apexes = await apex_service.resolve(edge, input_text)
-            self._report = self._report.merge(apex_service.report)
-            last_apexes = apexes
-
-            extractor = ActionExtraction()
-            ac_candidates = await extractor.resolve(
-                edge, input_text,
-                not_like_these=wheel.transformations,
-            )
-            self._report = self._report.merge(extractor.report)
-
             edge_data[edge.hash] = _EdgeProcessingData(
-                ac_candidates=ac_candidates or [],
-                apexes=apexes,
                 source_segment=source_segment,
                 target_segment=target_segment,
             )
+            phase1_tasks.append((edge, asyncio.ensure_future(
+                self._phase1_for_edge(edge, wheel, input_text)
+            )))
+
+        # Await Phase 1 tasks in parallel
+        if phase1_tasks:
+            results = await asyncio.gather(
+                *[t for _, t in phase1_tasks],
+                return_exceptions=True,
+            )
+            for (edge, _), result in zip(phase1_tasks, results):
+                assert edge.hash is not None
+                if isinstance(result, Exception):
+                    logging.getLogger(__name__).warning(
+                        "Phase 1 failed for edge %s: %s", edge.short_hash, result
+                    )
+                    edge_data[edge.hash] = _EdgeProcessingData(skip=True)
+                    continue
+                apexes, ac_candidates, report = result
+                self._report = self._report.merge(report)
+                if apexes:
+                    last_apexes = apexes
+                data = edge_data[edge.hash]
+                data.apexes = apexes
+                data.ac_candidates = ac_candidates or []
+
+        # Phase 2: Generate tetrads in parallel
+        generation_tasks: list[tuple[Transition, _EdgeProcessingData, ActionCandidateResultDto, asyncio.Task]] = []
 
-        # Phase 2: Generate tetrads using opposite Ac+ for Re-side
         for edge, opposite_edge in [(edge_a, edge_b), (edge_b, edge_a)]:
             assert edge.hash is not None
             assert opposite_edge.hash is not None
             data = edge_data.get(edge.hash)
             if not data or data.existing or data.skip:
                 continue
-
             if not data.ac_candidates:
                 continue
-
-            source_segment = data.source_segment
-            target_segment = data.target_segment
-            apexes = data.apexes
-            if not source_segment or not target_segment or not apexes:
+            if not data.source_segment or not data.target_segment or not data.apexes:
                 continue
 
-            # Get opposite edge's Ac+ candidates for Re-side context
             opp_data = edge_data.get(opposite_edge.hash)
             opp_ac_candidates = opp_data.ac_candidates if opp_data else []
 
@@ -245,19 +275,72 @@ class ExploreTransformations(ReasonableConcern[ExploreTransformationsResult]):
                 if not opposite_ac:
                     continue
 
-                generator = TransformationGeneration()
-                tetrad = await generator.resolve(
-                    edge, ac_plus, opposite_ac, apexes, input_text
+                task = asyncio.ensure_future(
+                    self._generate_tetrad(edge, ac_plus, opposite_ac, data.apexes, input_text)
                 )
-                self._report = self._report.merge(generator.report)
+                generation_tasks.append((edge, data, ac_plus, task))
 
+        # Await all generation tasks and create graph nodes sequentially
+        all_new: list[Transformation] = []
+        if generation_tasks:
+            tetrad_results = await asyncio.gather(
+                *[t for _, _, _, t in generation_tasks],
+                return_exceptions=True,
+            )
+            for (edge, data, _, _), result in zip(generation_tasks, tetrad_results):
+                if isinstance(result, Exception):
+                    logging.getLogger(__name__).warning(
+                        "Tetrad generation failed for edge %s: %s", edge.short_hash, result
+                    )
+                    continue
+                tetrad, report = result
+                self._report = self._report.merge(report)
+                assert data.source_segment is not None
+                assert data.target_segment is not None
                 transformation = self._create_transformation(
-                    nexus, edge, source_segment, target_segment, tetrad,
+                    nexus, edge, data.source_segment, data.target_segment, tetrad,
                 )
                 all_new.append(transformation)
 
         return all_existing, all_new, last_apexes
 
+    async def _phase1_for_edge(
+        self,
+        edge: Transition,
+        wheel: Wheel,
+        input_text: str,
+    ) -> tuple[Optional[ApexDerivationResultDto], list[ActionCandidateResultDto], Any]:
+        """Run ApexDerivation + ActionExtraction for a single edge. Returns (apexes, candidates, merged_report)."""
+        from dialectical_framework.agents.execution_report import ExecutionReport
+
+        merged_report = ExecutionReport(tool=self.__class__.__name__)
+
+        apex_service = ApexDerivation()
+        apexes = await apex_service.resolve(edge, input_text)
+        merged_report = merged_report.merge(apex_service.report)
+
+        extractor = ActionExtraction()
+        ac_candidates = await extractor.resolve(
+            edge, input_text,
+            not_like_these=wheel.transformations,
+        )
+        merged_report = merged_report.merge(extractor.report)
+
+        return apexes, ac_candidates or [], merged_report
+
+    async def _generate_tetrad(
+        self,
+        edge: Transition,
+        ac_plus: ActionCandidateResultDto,
+        opposite_ac: ActionCandidateResultDto,
+        apexes: ApexDerivationResultDto,
+        input_text: str,
+    ) -> tuple[TransformationTetradDto, Any]:
+        """Run TransformationGeneration for one candidate. Returns (tetrad, report)."""
+        generator = TransformationGeneration()
+        tetrad = await generator.resolve(edge, ac_plus, opposite_ac, apexes, input_text)
+        return tetrad, generator.report
+
     @staticmethod
     def _find_matching_category(
         candidates: list[ActionCandidateResultDto],

dialectical_framework-1.2.1/src/dialectical_framework/utils/concurrency.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import asyncio
+import os
+from contextlib import asynccontextmanager
+from typing import AsyncIterator
+
+_semaphore: asyncio.Semaphore | None = None
+_disabled: bool | None = None
+
+
+def _init() -> None:
+    global _semaphore, _disabled
+    if _disabled is not None:
+        return
+    raw = os.environ.get("DIALEXITY_MAX_CONCURRENT_LLM_CALLS", "0")
+    try:
+        limit = int(raw)
+    except ValueError:
+        limit = 0
+    if limit > 0:
+        _semaphore = asyncio.Semaphore(limit)
+        _disabled = False
+    else:
+        _disabled = True
+
+
+@asynccontextmanager
+async def llm_concurrency_slot() -> AsyncIterator[None]:
+    """Acquire a concurrency slot for an LLM call. Disabled by default (no-op)."""
+    _init()
+    if _disabled:
+        yield
+    else:
+        assert _semaphore is not None
+        async with _semaphore:
+            yield

{dialectical_framework-1.2.0 → dialectical_framework-1.2.1}/src/dialectical_framework/utils/use_brain.py

@@ -13,6 +13,7 @@ from mirascope.llm.exceptions import ParseError
 from dialectical_framework.enums.di import DI
 from dialectical_framework.settings import Settings
 from dialectical_framework.utils.bedrock_provider import ensure_bedrock_provider
+from dialectical_framework.utils.concurrency import llm_concurrency_slot
 
 if TYPE_CHECKING:
     from mirascope.llm.calls import AsyncCall
@@ -134,12 +135,14 @@ def use_brain(
                 return _llm_call
 
             attempts = max(1, retry_max)
-            delay = 10.0
-            last_error: Optional[ParseError] = None
+            parse_delay = 10.0
+            rate_delay = 30.0
+            last_error: Exception | None = None
 
             for attempt in range(attempts):
                 try:
-                    response = await _llm_call()
+                    async with llm_concurrency_slot():
+                        response = await _llm_call()
                     _trace_generation(
                         response=response,
                         model=resolved,
@@ -153,8 +156,20 @@ def use_brain(
                 except ParseError as e:
                     last_error = e
                     if attempt < attempts - 1:
-                        await asyncio.sleep(delay)
-                        delay = min(delay * 2.0, 120.0)
+                        await asyncio.sleep(parse_delay)
+                        parse_delay = min(parse_delay * 2.0, 120.0)
+                except Exception as e:
+                    if _is_rate_limit_error(e):
+                        last_error = e
+                        logging.getLogger(__name__).warning(
+                            "Rate limit hit (attempt %d/%d), backing off %.0fs",
+                            attempt + 1, attempts, rate_delay,
+                        )
+                        if attempt < attempts - 1:
+                            await asyncio.sleep(rate_delay)
+                            rate_delay = min(rate_delay * 2.0, 300.0)
+                    else:
+                        raise
 
             raise last_error  # type: ignore[misc]
 
@@ -221,6 +236,18 @@ def _serialize_message(msg: Any) -> dict[str, Any]:
     return {"content": str(msg)}
 
 
+def _is_rate_limit_error(e: Exception) -> bool:
+    """Detect rate-limit / throttling errors from various providers."""
+    if hasattr(e, "status_code") and getattr(e, "status_code", None) == 429:
+        return True
+    msg = str(e)
+    if "ThrottlingException" in msg or "TooManyRequests" in msg:
+        return True
+    if "rate" in msg.lower() and ("limit" in msg.lower() or "exceeded" in msg.lower()):
+        return True
+    return False
+
+
 @inject
 def _get_ai_model(settings: Settings = Provide[DI.settings]) -> str:
     return settings.ai_model