abstractcore 2.6.8__tar.gz → 2.6.9__tar.gz

{abstractcore-2.6.8 → abstractcore-2.6.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstractcore
-Version: 2.6.8
+Version: 2.6.9
 Summary: Unified interface to all LLM providers with essential infrastructure for tool calling, streaming, and model management
 Author-email: Laurent-Philippe Albou <contact@abstractcore.ai>
 Maintainer-email: Laurent-Philippe Albou <contact@abstractcore.ai>
@@ -195,50 +195,6 @@ response = llm.generate(
 print(response.content)
 ```
 
-### Tool Execution Modes
-
-AbstractCore supports two tool execution modes:
-
-**Mode 1: Passthrough (Default)** - Returns raw tool call tags for downstream processing
-
-```python
-from abstractcore import create_llm
-from abstractcore.tools import tool
-
-@tool(name="get_weather", description="Get weather for a city")
-def get_weather(city: str) -> str:
-    return f"Weather in {city}: Sunny, 22°C"
-
-llm = create_llm("ollama", model="qwen3:4b")  # execute_tools=False by default
-response = llm.generate("What's the weather in Paris?", tools=[get_weather])
-# response.content contains raw tool call tags: <|tool_call|>...
-# Downstream runtime (AbstractRuntime, Codex, Claude Code) parses and executes
-```
-
-**Use case**: Agent loops, AbstractRuntime, Codex, Claude Code, custom orchestration
-
-**Mode 2: Direct Execution** - AbstractCore executes tools and returns results
-
-```python
-from abstractcore import create_llm
-from abstractcore.tools import tool
-from abstractcore.tools.registry import register_tool
-
-@tool(name="get_weather", description="Get weather for a city")
-def get_weather(city: str) -> str:
-    return f"Weather in {city}: Sunny, 22°C"
-
-register_tool(get_weather)  # Required for direct execution
-
-llm = create_llm("ollama", model="qwen3:4b", execute_tools=True)
-response = llm.generate("What's the weather in Paris?", tools=[get_weather])
-# response.content contains executed tool results
-```
-
-**Use case**: Simple scripts, single-turn tool use
-
-> **Note**: The `@tool` decorator creates metadata but does NOT register globally. Tools are passed explicitly to `generate()`. Use `register_tool()` only when using direct execution mode.
-
 ### Response Object (GenerateResponse)
 
 Every LLM generation returns a **GenerateResponse** object with consistent structure across all providers:

{abstractcore-2.6.8 → abstractcore-2.6.9}/README.md

@@ -65,50 +65,6 @@ response = llm.generate(
 print(response.content)
 ```
 
-### Tool Execution Modes
-
-AbstractCore supports two tool execution modes:
-
-**Mode 1: Passthrough (Default)** - Returns raw tool call tags for downstream processing
-
-```python
-from abstractcore import create_llm
-from abstractcore.tools import tool
-
-@tool(name="get_weather", description="Get weather for a city")
-def get_weather(city: str) -> str:
-    return f"Weather in {city}: Sunny, 22°C"
-
-llm = create_llm("ollama", model="qwen3:4b")  # execute_tools=False by default
-response = llm.generate("What's the weather in Paris?", tools=[get_weather])
-# response.content contains raw tool call tags: <|tool_call|>...
-# Downstream runtime (AbstractRuntime, Codex, Claude Code) parses and executes
-```
-
-**Use case**: Agent loops, AbstractRuntime, Codex, Claude Code, custom orchestration
-
-**Mode 2: Direct Execution** - AbstractCore executes tools and returns results
-
-```python
-from abstractcore import create_llm
-from abstractcore.tools import tool
-from abstractcore.tools.registry import register_tool
-
-@tool(name="get_weather", description="Get weather for a city")
-def get_weather(city: str) -> str:
-    return f"Weather in {city}: Sunny, 22°C"
-
-register_tool(get_weather)  # Required for direct execution
-
-llm = create_llm("ollama", model="qwen3:4b", execute_tools=True)
-response = llm.generate("What's the weather in Paris?", tools=[get_weather])
-# response.content contains executed tool results
-```
-
-**Use case**: Simple scripts, single-turn tool use
-
-> **Note**: The `@tool` decorator creates metadata but does NOT register globally. Tools are passed explicitly to `generate()`. Use `register_tool()` only when using direct execution mode.
-
 ### Response Object (GenerateResponse)
 
 Every LLM generation returns a **GenerateResponse** object with consistent structure across all providers:

{abstractcore-2.6.8 → abstractcore-2.6.9}/abstractcore/assets/model_capabilities.json

@@ -638,26 +638,17 @@
       "max_tokens": 262144
     },
     "qwen3-coder-30b": {
-      "max_output_tokens": 65536,
+      "max_output_tokens": 8192,
       "tool_support": "native",
       "structured_output": "native",
       "parallel_tools": true,
       "vision_support": false,
       "audio_support": false,
-      "architecture": "mixture_of_experts",
-      "total_parameters": "30.5B",
-      "active_parameters": "3.3B",
-      "experts": 128,
-      "experts_activated": 8,
-      "notes": "Code-focused MoE model (30.5B total/3.3B active, 128 experts/8 activated). Native tool support via chatml-function-calling format. Supports up to 1M tokens with YaRN extension.",
-      "source": "Qwen HuggingFace model card 2025",
+      "notes": "Code-focused model with native tool support via chatml-function-calling format",
+      "source": "Alibaba official docs",
       "canonical_name": "qwen3-coder-30b",
-      "aliases": [
-        "Qwen/Qwen3-Coder-30B-A3B-Instruct",
-        "qwen3-coder-30b-a3b",
-        "qwen3-coder-30b-a3b-instruct"
-      ],
-      "max_tokens": 262144
+      "aliases": [],
+      "max_tokens": 32768
     },
     "qwen2-vl": {
       "max_output_tokens": 8192,

{abstractcore-2.6.8 → abstractcore-2.6.9}/abstractcore/processing/__init__.py

@@ -5,14 +5,14 @@ Basic text processing capabilities built on top of AbstractCore,
 demonstrating how to leverage the core infrastructure for real-world tasks.
 """
 
-from .basic_summarizer import BasicSummarizer, SummaryStyle, SummaryLength, CompressionMode
+from .basic_summarizer import BasicSummarizer, SummaryStyle, SummaryLength
 from .basic_extractor import BasicExtractor
 from .basic_judge import BasicJudge, JudgmentCriteria, Assessment, create_judge
 from .basic_deepsearch import BasicDeepSearch, ResearchReport, ResearchFinding, ResearchPlan, ResearchSubTask
 from .basic_intent import BasicIntentAnalyzer, IntentType, IntentDepth, IntentContext, IdentifiedIntent, IntentAnalysisOutput
 
 __all__ = [
-    'BasicSummarizer', 'SummaryStyle', 'SummaryLength', 'CompressionMode',
+    'BasicSummarizer', 'SummaryStyle', 'SummaryLength',
     'BasicExtractor',
     'BasicJudge', 'JudgmentCriteria', 'Assessment', 'create_judge',
     'BasicDeepSearch', 'ResearchReport', 'ResearchFinding', 'ResearchPlan', 'ResearchSubTask',

{abstractcore-2.6.8 → abstractcore-2.6.9}/abstractcore/processing/basic_summarizer.py

@@ -35,42 +35,6 @@ class SummaryLength(Enum):
     COMPREHENSIVE = "comprehensive"  # Full analysis with context
 
 
-class CompressionMode(Enum):
-    """Compression aggressiveness for chat history summarization.
-
-    Controls how aggressively the summarizer compresses conversation history:
-    - LIGHT: Keep most information, only remove redundancy
-    - STANDARD: Balanced compression, main points and context
-    - HEAVY: Aggressive compression, only critical information
-    """
-    LIGHT = "light"
-    STANDARD = "standard"
-    HEAVY = "heavy"
-
-
-# Compression mode-specific instructions for summarization prompts
-COMPRESSION_INSTRUCTIONS = {
-    CompressionMode.LIGHT: (
-        "Preserve most details from this conversation while removing only redundancy. "
-        "Keep: all key decisions and outcomes, important context and background, "
-        "specific details/names/numbers/technical terms, all tool calls and results, "
-        "error messages and resolutions. Remove only: repetitive greetings, duplicate information."
-    ),
-    CompressionMode.STANDARD: (
-        "Summarize with balanced compression, keeping main points and essential context. "
-        "Keep: key decisions and rationale, important outcomes, critical context for ongoing work, "
-        "unresolved items and pending tasks. Remove: intermediate reasoning steps, "
-        "exploratory tangents, detailed tool outputs (keep only key findings)."
-    ),
-    CompressionMode.HEAVY: (
-        "Extract only the most critical information. Keep ONLY: final decisions made, "
-        "critical outcomes (success/failure), essential context to continue work, "
-        "blocking issues and hard dependencies. Remove: all exploratory discussion, "
-        "all intermediate steps, all detailed outputs, all background explanations."
-    ),
-}
-
-
 class LLMSummaryOutput(BaseModel):
     """LLM-generated summary output (without word counts)"""
     summary: str = Field(description="The main summary text")
@@ -529,8 +493,7 @@ Create a unified summary that represents the entire document effectively."""
         self,
         messages: List[dict],
         preserve_recent: int = 6,
-        focus: Optional[str] = None,
-        compression_mode: CompressionMode = CompressionMode.STANDARD
+        focus: Optional[str] = None
     ) -> SummaryOutput:
         """
         Specialized method for chat history summarization following SOTA 2025 practices
@@ -539,7 +502,6 @@ Create a unified summary that represents the entire document effectively."""
             messages: List of message dicts with 'role' and 'content' keys
             preserve_recent: Number of recent messages to keep intact (default 6)
             focus: Optional focus for summarization (e.g., "key decisions", "technical solutions")
-            compression_mode: How aggressively to compress (LIGHT, STANDARD, HEAVY)
 
         Returns:
             SummaryOutput: Structured summary optimized for chat history context
@@ -549,67 +511,36 @@ Create a unified summary that represents the entire document effectively."""
         - Focuses on decisions, solutions, and ongoing topics
         - Maintains user intent and assistant responses
         - Optimized for chat continuation rather than standalone summary
-
-        Compression Modes:
-        - LIGHT: Keep most information, only remove redundancy
-        - STANDARD: Balanced compression, main points and context
-        - HEAVY: Aggressive compression, only critical information
         """
-        # Build focus with compression instructions
-        compression_instruction = COMPRESSION_INSTRUCTIONS.get(
-            compression_mode,
-            COMPRESSION_INSTRUCTIONS[CompressionMode.STANDARD]
-        )
-
-        # Combine user focus with compression instruction
-        if focus:
-            effective_focus = f"{compression_instruction} Focus especially on: {focus}"
-        else:
-            effective_focus = compression_instruction
-
-        # Map compression mode to summary length for appropriate output size
-        length_map = {
-            CompressionMode.LIGHT: SummaryLength.DETAILED,
-            CompressionMode.STANDARD: SummaryLength.STANDARD,
-            CompressionMode.HEAVY: SummaryLength.BRIEF,
-        }
-        target_length = length_map.get(compression_mode, SummaryLength.STANDARD)
-
-        logger.debug("Chat history summarization with compression mode",
-                    message_count=len(messages),
-                    preserve_recent=preserve_recent,
-                    compression_mode=compression_mode.value,
-                    target_length=target_length.value)
-
         if len(messages) <= preserve_recent:
             # If short enough, just summarize normally
-            logger.debug("Chat history is short, using standard summarization",
-                        message_count=len(messages),
+            logger.debug("Chat history is short, using standard summarization", 
+                        message_count=len(messages), 
                         preserve_recent=preserve_recent)
             chat_text = self._format_chat_messages_to_text(messages)
             return self.summarize(
                 chat_text,
-                focus=effective_focus,
+                focus=focus or "conversational context and key information",
                 style=SummaryStyle.CONVERSATIONAL,
-                length=target_length
+                length=SummaryLength.STANDARD
             )
 
         # Split into older messages (to summarize) and recent messages (to preserve)
         older_messages = messages[:-preserve_recent]
         recent_messages = messages[-preserve_recent:]
-
-        logger.debug("Splitting chat history for summarization",
+        
+        logger.debug("Splitting chat history for summarization", 
                     total_messages=len(messages),
                     older_messages=len(older_messages),
                     recent_messages=len(recent_messages))
 
-        # Summarize older messages with conversational focus and compression mode
+        # Summarize older messages with conversational focus
         older_text = self._format_chat_messages_to_text(older_messages)
         older_summary = self.summarize(
             older_text,
-            focus=effective_focus,
+            focus=focus or "key decisions, solutions, and ongoing context",
             style=SummaryStyle.CONVERSATIONAL,
-            length=target_length
+            length=SummaryLength.DETAILED
         )
 
         # The summary should ONLY contain the older messages summary

{abstractcore-2.6.8 → abstractcore-2.6.9}/abstractcore/providers/base.py

@@ -5,7 +5,6 @@ Base provider with integrated telemetry, events, and exception handling.
 import time
 import uuid
 import asyncio
-import warnings
 from collections import deque
 from typing import List, Dict, Any, Optional, Union, Iterator, AsyncIterator, Type
 from abc import ABC, abstractmethod
@@ -61,13 +60,6 @@ class BaseProvider(AbstractCoreInterface, ABC):
         # execute_tools: True = AbstractCore executes tools (legacy mode)
         #                False = Pass-through mode (default - for API server / agentic CLI)
         self.execute_tools = kwargs.get('execute_tools', False)
-        if self.execute_tools:
-            warnings.warn(
-                "execute_tools=True is deprecated. Prefer passing tools explicitly to generate() "
-                "and executing tool calls in the host/runtime via a ToolExecutor.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
 
         # Setup retry manager with optional configuration
         retry_config = kwargs.get('retry_config', None)
@@ -210,12 +202,6 @@ class BaseProvider(AbstractCoreInterface, ABC):
         """
         trace_id = str(uuid.uuid4())
 
-        # If trace retention is disabled, still return a trace_id for correlation
-        # without constructing/storing a full trace payload.
-        maxlen = getattr(getattr(self, "_traces", None), "maxlen", None)
-        if maxlen == 0:
-            return trace_id
-
         # Extract generation parameters
         temperature = kwargs.get('temperature', self.temperature)
         max_tokens = kwargs.get('max_tokens', self.max_tokens)
@@ -422,13 +408,6 @@ class BaseProvider(AbstractCoreInterface, ABC):
         
         # Handle tool execution control
         should_execute_tools = execute_tools if execute_tools is not None else self.execute_tools
-        if should_execute_tools and converted_tools:
-            warnings.warn(
-                "execute_tools=True is deprecated. Prefer passing tools explicitly to generate() "
-                "and executing tool calls in the host/runtime via a ToolExecutor.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
         if not should_execute_tools and converted_tools:
             # If tools are provided but execution is disabled,
             # we still pass them to the provider for generation but won't execute them
@@ -1511,10 +1490,28 @@ Please provide a structured response."""
         Returns:
             GenerateResponse, AsyncIterator[GenerateResponse] for streaming, or BaseModel for structured output
         """
-        return await self._agenerate_internal(
+        response = await self._agenerate_internal(
             prompt, messages, system_prompt, tools, media, stream, **kwargs
         )
 
+        # Capture interaction trace if enabled (match sync generate_with_telemetry behavior)
+        # Only for non-streaming responses that are GenerateResponse objects
+        if not stream and self.enable_tracing and response and isinstance(response, GenerateResponse):
+            trace_id = self._capture_trace(
+                prompt=prompt,
+                messages=messages,
+                system_prompt=system_prompt,
+                tools=tools,
+                response=response,
+                kwargs=kwargs
+            )
+            # Attach trace_id to response metadata
+            if not response.metadata:
+                response.metadata = {}
+            response.metadata['trace_id'] = trace_id
+
+        return response
+
     async def _agenerate_internal(self,
                                    prompt: str,
                                    messages: Optional[List[Dict]],
@@ -1577,4 +1574,4 @@ Please provide a structured response."""
         # Yield chunks asynchronously
         for chunk in sync_gen:
             yield chunk
-            await asyncio.sleep(0)  # Yield control to event loop
+            await asyncio.sleep(0)  # Yield control to event loop

{abstractcore-2.6.8 → abstractcore-2.6.9}/abstractcore/server/app.py

@@ -1956,39 +1956,6 @@ async def provider_chat_completions(
     _, model = parse_model_string(request.model)
     return await process_chat_completion(provider, model, request, http_request)
 
-
-def _extract_trace_metadata(http_request: Request) -> Dict[str, Any]:
-    """Extract trace metadata from request headers (schema-safe)."""
-    meta: Dict[str, Any] = {}
-
-    raw = (
-        http_request.headers.get("x-abstractcore-trace-metadata")
-        or http_request.headers.get("x-abstract-trace-metadata")
-    )
-    if raw:
-        try:
-            parsed = json.loads(raw)
-            if isinstance(parsed, dict):
-                meta.update(parsed)
-        except Exception:
-            # Ignore invalid metadata payloads; tracing is best-effort.
-            pass
-
-    header_map = {
-        "actor_id": "x-abstractcore-actor-id",
-        "session_id": "x-abstractcore-session-id",
-        "run_id": "x-abstractcore-run-id",
-        "parent_run_id": "x-abstractcore-parent-run-id",
-    }
-    for key, header in header_map.items():
-        val = http_request.headers.get(header)
-        if val is not None and key not in meta:
-            meta[key] = val
-
-    # Never log or return these directly; they are for internal correlation only.
-    return meta
-
-
 async def process_chat_completion(
     provider: str,
     model: str,
@@ -2052,11 +2019,6 @@ async def process_chat_completion(
         # Create LLM instance
         # Prepare provider-specific kwargs
         provider_kwargs = {}
-        trace_metadata = _extract_trace_metadata(http_request)
-        if trace_metadata:
-            # Enable trace capture (trace_id) without retaining full trace buffers by default.
-            provider_kwargs["enable_tracing"] = True
-            provider_kwargs.setdefault("max_traces", 0)
         if request.base_url:
             provider_kwargs["base_url"] = request.base_url
             logger.info(
@@ -2085,8 +2047,6 @@ async def process_chat_completion(
             "tool_choice": request.tool_choice if request.tools else None,
             "execute_tools": False,  # Server mode - don't execute tools
         }
-        if trace_metadata:
-            gen_kwargs["trace_metadata"] = trace_metadata
 
         # Add optional parameters
         if request.stop:
@@ -2121,18 +2081,9 @@ async def process_chat_completion(
                 )
             else:
                 response = llm.generate(**gen_kwargs)
-                openai_response = convert_to_openai_response(
+                return convert_to_openai_response(
                     response, provider, model, syntax_rewriter, request_id
                 )
-                trace_id = None
-                if hasattr(response, "metadata") and isinstance(getattr(response, "metadata"), dict):
-                    trace_id = response.metadata.get("trace_id")
-                if trace_id:
-                    return JSONResponse(
-                        content=openai_response,
-                        headers={"X-AbstractCore-Trace-Id": str(trace_id)},
-                    )
-                return openai_response
         finally:
             # Cleanup temporary files (base64 and downloaded images) with delay to avoid race conditions
             import threading
@@ -2457,4 +2408,4 @@ Debug Mode:
 # ============================================================================
 
 if __name__ == "__main__":
-    run_server_with_args()
+    run_server_with_args()

abstractcore-2.6.9/abstractcore/tools/__init__.py

@@ -0,0 +1,101 @@
+"""
+Universal tool support for AbstractCore.
+
+This package provides a unified tool system that works across all models
+and providers, whether they have native tool APIs or require prompting.
+
+Key components:
+- Core types (ToolDefinition, ToolCall, ToolResult)
+- Universal handler for all models
+- Architecture-based parsing and formatting
+- Tool registry for managing available tools
+
+Example usage:
+```python
+from abstractcore.tools import ToolDefinition, UniversalToolHandler, register_tool
+
+# Define a tool
+def list_files(directory: str = ".", pattern: str = "*") -> str:
+    '''List files in a directory.'''
+    import os, fnmatch
+    files = [f for f in os.listdir(directory) if fnmatch.fnmatch(f, pattern)]
+    return "\n".join(files)
+
+# Register the tool
+tool_def = ToolDefinition.from_function(list_files)
+
+# Create handler for a model
+handler = UniversalToolHandler("qwen3-coder:30b")
+
+# Get tool prompt for prompted models
+if handler.supports_prompted:
+    tool_prompt = handler.format_tools_prompt([tool_def])
+    print("Add this to your system prompt:")
+    print(tool_prompt)
+
+# Parse response for tool calls
+response = "I'll list the files. <|tool_call|>{'name': 'list_files', 'arguments': {'directory': '.'}}"
+tool_calls = handler.parse_response(response, mode="prompted")
+
+if tool_calls.has_tool_calls():
+    print("Tool calls found:", tool_calls.tool_calls)
+```
+"""
+
+# Core types
+from .core import (
+    ToolDefinition,
+    ToolCall,
+    ToolResult,
+    ToolCallResponse,
+    tool
+)
+
+# Handler
+from .handler import (
+    UniversalToolHandler,
+    create_handler
+)
+
+# Parser functions
+from .parser import (
+    detect_tool_calls,
+    parse_tool_calls,
+    format_tool_prompt
+)
+
+# Registry
+from .registry import (
+    ToolRegistry,
+    register_tool,
+    get_registry,
+    execute_tool,
+    execute_tools,
+    clear_registry
+)
+
+__all__ = [
+    # Core types
+    "ToolDefinition",
+    "ToolCall",
+    "ToolResult",
+    "ToolCallResponse",
+    "tool",
+
+    # Handler
+    "UniversalToolHandler",
+    "create_handler",
+
+    # Parser
+    "detect_tool_calls",
+    "parse_tool_calls",
+    "format_tool_prompt",
+
+    # Registry
+    "ToolRegistry",
+    "register_tool",
+    "get_registry",
+    "execute_tool",
+    "execute_tools",
+    "clear_registry",
+]