hdsp-jupyter-extension 2.0.22__py3-none-any.whl → 2.0.25__py3-none-any.whl

agent_server/context_providers/processor.py

@@ -0,0 +1,150 @@
+"""
+Context Processor
+
+Processes context commands in user input, injecting file contents and other
+context into the LLM prompt.
+"""
+
+import logging
+from typing import Optional
+
+from .base import BaseContextProvider, ContextProviderException, find_commands
+from .file import FileContextProvider
+
+logger = logging.getLogger(__name__)
+
+
+class ContextProcessor:
+    """
+    Processes context commands (@file, etc.) in user input.
+
+    This class:
+    1. Finds context commands in the user's message
+    2. Builds context content from the commands
+    3. Cleans the original message by replacing commands with references
+    """
+
+    def __init__(self, base_dir: str = "."):
+        """
+        Initialize the context processor.
+
+        Args:
+            base_dir: Base directory for resolving relative file paths
+        """
+        self.base_dir = base_dir
+        self.providers: dict[str, BaseContextProvider] = {
+            "@file": FileContextProvider(base_dir=base_dir),
+        }
+
+    def process_message(self, message: str) -> tuple[str, str, list[str]]:
+        """
+        Process context commands in a message.
+
+        Args:
+            message: The user's message containing context commands
+
+        Returns:
+            Tuple of:
+            - context: Combined context string to prepend to the prompt
+            - cleaned_message: Message with commands replaced by references
+            - errors: List of error messages (if any commands failed)
+        """
+        context_parts = []
+        errors = []
+        cleaned_message = message
+
+        # Process each provider
+        for provider_id, provider in self.providers.items():
+            commands = find_commands(provider, message)
+
+            for command in commands:
+                try:
+                    # Generate context for this command
+                    context = provider.make_context(command)
+                    context_parts.append(context)
+
+                    # Replace command in message
+                    replacement = provider.replace_command(command)
+                    cleaned_message = cleaned_message.replace(
+                        command.cmd, replacement, 1
+                    )
+
+                    logger.info(f"Processed context command: {command.cmd}")
+
+                except ContextProviderException as e:
+                    errors.append(str(e))
+                    logger.warning(f"Context command failed: {command.cmd} - {e}")
+
+        # Combine all context
+        combined_context = "\n\n".join(context_parts) if context_parts else ""
+
+        return combined_context, cleaned_message, errors
+
+    def has_context_commands(self, message: str) -> bool:
+        """
+        Check if a message contains any context commands.
+
+        Args:
+            message: The message to check
+
+        Returns:
+            True if message contains context commands
+        """
+        for provider in self.providers.values():
+            if find_commands(provider, message):
+                return True
+        return False
+
+    def build_prompt_with_context(
+        self,
+        message: str,
+        system_context: Optional[str] = None,
+    ) -> tuple[str, list[str]]:
+        """
+        Build a complete prompt with injected context.
+
+        Args:
+            message: The user's message
+            system_context: Optional additional system context
+
+        Returns:
+            Tuple of:
+            - prompt: Complete prompt with context
+            - errors: List of any errors that occurred
+        """
+        context, cleaned_message, errors = self.process_message(message)
+
+        # Build the final prompt
+        parts = []
+
+        if context:
+            parts.append("### Provided Context ###")
+            parts.append(context)
+            parts.append("### End of Context ###\n")
+
+        if system_context:
+            parts.append(system_context)
+
+        parts.append(cleaned_message)
+
+        prompt = "\n\n".join(parts)
+
+        return prompt, errors
+
+
+def process_context_commands(
+    message: str,
+    base_dir: str = ".",
+) -> tuple[str, str, list[str]]:
+    """
+    Convenience function to process context commands.
+
+    Args:
+        message: User's message
+        base_dir: Base directory for file resolution
+
+    Returns:
+        Tuple of (context, cleaned_message, errors)
+    """
+    processor = ContextProcessor(base_dir=base_dir)
+    return processor.process_message(message)

agent_server/langchain/models/gpt_oss_chat.py

@@ -98,7 +98,9 @@ class ChatGPTOSS(BaseChatModel):
                     "function": {
                         "name": tool.name,
                         "description": tool.description or "",
-                        "parameters": tool.args_schema.schema() if tool.args_schema else {"type": "object", "properties": {}},
+                        "parameters": tool.args_schema.schema()
+                        if tool.args_schema
+                        else {"type": "object", "properties": {}},
                     },
                 }
                 formatted_tools.append(tool_schema)
@@ -116,6 +118,7 @@ class ChatGPTOSS(BaseChatModel):
             temperature=self.temperature,
             max_tokens=self.max_tokens,
             streaming=self.streaming,
+            callbacks=self.callbacks,  # Preserve callbacks (e.g., LLMTraceLogger)
         )
         new_instance._tools = formatted_tools
         new_instance._tool_choice = tool_choice
@@ -131,15 +134,19 @@ class ChatGPTOSS(BaseChatModel):
         for msg in messages:
             if isinstance(msg, SystemMessage):
                 # Convert system to developer for gpt-oss instruction hierarchy
-                result.append({
-                    "role": "developer",
-                    "content": msg.content,
-                })
+                result.append(
+                    {
+                        "role": "developer",
+                        "content": msg.content,
+                    }
+                )
             elif isinstance(msg, HumanMessage):
-                result.append({
-                    "role": "user",
-                    "content": msg.content,
-                })
+                result.append(
+                    {
+                        "role": "user",
+                        "content": msg.content,
+                    }
+                )
             elif isinstance(msg, AIMessage):
                 ai_msg: Dict[str, Any] = {
                     "role": "assistant",
@@ -154,25 +161,31 @@ class ChatGPTOSS(BaseChatModel):
                             "type": "function",
                             "function": {
                                 "name": tc["name"],
-                                "arguments": json.dumps(tc["args"]) if isinstance(tc["args"], dict) else tc["args"],
+                                "arguments": json.dumps(tc["args"])
+                                if isinstance(tc["args"], dict)
+                                else tc["args"],
                             },
                         }
                         for tc in tool_calls
                     ]
                 result.append(ai_msg)
             elif isinstance(msg, ToolMessage):
-                result.append({
-                    "role": "tool",
-                    "tool_call_id": msg.tool_call_id,
-                    "content": msg.content,
-                })
+                result.append(
+                    {
+                        "role": "tool",
+                        "tool_call_id": msg.tool_call_id,
+                        "content": msg.content,
+                    }
+                )
             else:
                 # Fallback for other message types
                 role = getattr(msg, "role", "user")
-                result.append({
-                    "role": role,
-                    "content": msg.content,
-                })
+                result.append(
+                    {
+                        "role": role,
+                        "content": msg.content,
+                    }
+                )
 
         return result
 
@@ -204,12 +217,14 @@ class ChatGPTOSS(BaseChatModel):
                     args = json.loads(tc.function.arguments)
                 except json.JSONDecodeError:
                     args = {"raw": tc.function.arguments}
-                tool_calls_list.append({
-                    "name": tc.function.name,
-                    "args": args,
-                    "id": tc.id,
-                    "type": "tool_call",
-                })
+                tool_calls_list.append(
+                    {
+                        "name": tc.function.name,
+                        "args": args,
+                        "id": tc.id,
+                        "type": "tool_call",
+                    }
+                )
 
         ai_message = AIMessage(
             content=content,
@@ -260,7 +275,9 @@ class ChatGPTOSS(BaseChatModel):
                 request_kwargs["tool_choice"] = self._tool_choice
 
         # Make API call
-        logger.debug(f"ChatGPTOSS request: model={self.model}, messages_count={len(openai_messages)}")
+        logger.debug(
+            f"ChatGPTOSS request: model={self.model}, messages_count={len(openai_messages)}"
+        )
         response = self.client.chat.completions.create(**request_kwargs)
 
         return self._create_chat_result(response)
@@ -328,12 +345,14 @@ class ChatGPTOSS(BaseChatModel):
                             tool_calls_accum[idx]["arguments"] += tc.function.arguments
 
                     # Build tool call chunk for LangChain
-                    tool_call_chunks.append({
-                        "index": idx,
-                        "id": tool_calls_accum[idx]["id"],
-                        "name": tool_calls_accum[idx]["name"],
-                        "args": tool_calls_accum[idx]["arguments"],
-                    })
+                    tool_call_chunks.append(
+                        {
+                            "index": idx,
+                            "id": tool_calls_accum[idx]["id"],
+                            "name": tool_calls_accum[idx]["name"],
+                            "args": tool_calls_accum[idx]["arguments"],
+                        }
+                    )
 
             # Create chunk message
             chunk_message = AIMessageChunk(

agent_server/main.py

@@ -14,7 +14,7 @@ from contextlib import asynccontextmanager
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 
-from agent_server.routers import agent, chat, config, file_resolver, health, rag
+from agent_server.routers import agent, chat, config, context, file_resolver, health, rag
 
 # Optional LangChain router (requires langchain dependencies)
 try:
@@ -158,6 +158,7 @@ app.include_router(agent.router, prefix="/agent", tags=["Agent"])
 app.include_router(chat.router, prefix="/chat", tags=["Chat"])
 app.include_router(rag.router, prefix="/rag", tags=["RAG"])
 app.include_router(file_resolver.router, prefix="/file", tags=["File Resolution"])
+app.include_router(context.router, prefix="/context", tags=["Context Providers"])
 
 # Register LangChain agent router if available
 if LANGCHAIN_AVAILABLE:

agent_server/routers/chat.py

@@ -2,10 +2,12 @@
 Chat Router - Chat and streaming endpoints
 
 Handles conversational interactions with the LLM.
+Supports @file context injection for including file contents in prompts.
 """
 
 import json
 import logging
+import os
 from typing import Any, AsyncGenerator, Dict
 
 from fastapi import APIRouter, HTTPException
@@ -14,6 +16,7 @@ from hdsp_agent_core.managers.config_manager import ConfigManager
 from hdsp_agent_core.managers.session_manager import get_session_manager
 from hdsp_agent_core.models.chat import ChatRequest, ChatResponse
 
+from agent_server.context_providers import ContextProcessor
 from agent_server.core.llm_service import LLMService
 
 router = APIRouter()
@@ -83,6 +86,7 @@ async def chat_message(request: ChatRequest) -> Dict[str, Any]:
     """
     Send a chat message and get a response.
 
+    Supports @file context injection (e.g., "@file:path/to/file.py").
     Maintains conversation context across messages using conversation ID.
     """
     logger.info(f"Chat message received: {request.message[:100]}...")
@@ -104,25 +108,52 @@ async def chat_message(request: ChatRequest) -> Dict[str, Any]:
         conversation_id = _get_or_create_conversation(request.conversationId)
 
         # Build context from history
-        context = _build_context(conversation_id)
+        history_context = _build_context(conversation_id)
+
+        # Process @file and other context commands
+        base_dir = getattr(request, 'baseDir', None) or os.getcwd()
+        context_processor = ContextProcessor(base_dir=base_dir)
+        file_context, cleaned_message, context_errors = context_processor.process_message(
+            request.message
+        )
+
+        # Log any context processing errors
+        if context_errors:
+            logger.warning(f"Context processing errors: {context_errors}")
+
+        # Combine all context
+        all_context_parts = []
+        if file_context:
+            all_context_parts.append(file_context)
+        if history_context:
+            all_context_parts.append(history_context)
+        combined_context = "\n\n".join(all_context_parts) if all_context_parts else None
 
         # Call LLM with client-provided config
         llm_service = LLMService(config)
-        response = await llm_service.generate_response(request.message, context=context)
+        response = await llm_service.generate_response(
+            cleaned_message, context=combined_context
+        )
 
-        # Store messages
-        _store_messages(conversation_id, request.message, response)
+        # Store messages (use cleaned message for history)
+        _store_messages(conversation_id, cleaned_message, response)
 
         # Get model info
         provider = config.get("provider", "unknown")
         model = config.get(provider, {}).get("model", "unknown")
 
-        return {
+        result = {
             "response": response,
             "conversationId": conversation_id,
             "model": f"{provider}/{model}",
         }
 
+        # Include context errors if any
+        if context_errors:
+            result["contextErrors"] = context_errors
+
+        return result
+
     except HTTPException:
         raise
     except Exception as e:
@@ -135,6 +166,7 @@ async def chat_stream(request: ChatRequest) -> StreamingResponse:
     """
     Send a chat message and get a streaming response.
 
+    Supports @file context injection (e.g., "@file:path/to/file.py").
     Returns Server-Sent Events (SSE) with partial responses.
     """
     logger.info(f"Stream chat request: {request.message[:100]}...")
@@ -154,21 +186,40 @@ async def chat_stream(request: ChatRequest) -> StreamingResponse:
             # Get or create conversation
             conversation_id = _get_or_create_conversation(request.conversationId)
 
-            # Build context
-            context = _build_context(conversation_id)
+            # Build context from history
+            history_context = _build_context(conversation_id)
+
+            # Process @file and other context commands
+            base_dir = getattr(request, 'baseDir', None) or os.getcwd()
+            context_processor = ContextProcessor(base_dir=base_dir)
+            file_context, cleaned_message, context_errors = context_processor.process_message(
+                request.message
+            )
+
+            # Send context errors as a warning event
+            if context_errors:
+                yield f"data: {json.dumps({'warning': 'Context errors: ' + '; '.join(context_errors)})}\n\n"
+
+            # Combine all context
+            all_context_parts = []
+            if file_context:
+                all_context_parts.append(file_context)
+            if history_context:
+                all_context_parts.append(history_context)
+            combined_context = "\n\n".join(all_context_parts) if all_context_parts else None
 
             # Stream LLM response with client-provided config
             llm_service = LLMService(config)
             full_response = ""
 
             async for chunk in llm_service.generate_response_stream(
-                request.message, context=context
+                cleaned_message, context=combined_context
             ):
                 full_response += chunk
                 yield f"data: {json.dumps({'content': chunk, 'done': False})}\n\n"
 
-            # Store messages after streaming complete
-            _store_messages(conversation_id, request.message, full_response)
+            # Store messages after streaming complete (use cleaned message)
+            _store_messages(conversation_id, cleaned_message, full_response)
 
             # Send final chunk with conversation ID
             yield f"data: {json.dumps({'content': '', 'done': True, 'conversationId': conversation_id})}\n\n"

agent_server/routers/context.py

@@ -0,0 +1,168 @@
+"""
+Context Router - Context provider autocomplete and resolution
+
+Handles @file and other context command autocomplete and processing.
+Inspired by jupyter-ai's autocomplete API.
+"""
+
+import logging
+import os
+from typing import Optional
+
+from fastapi import APIRouter, Query
+from pydantic import BaseModel
+
+from agent_server.context_providers import FileContextProvider, ResetContextProvider
+from agent_server.context_providers.base import ListOptionsResponse
+
+router = APIRouter()
+logger = logging.getLogger(__name__)
+
+
+# All available providers (context and action)
+def _get_all_providers(base_dir: str):
+    """Get all available context/action providers."""
+    return {
+        "@file": FileContextProvider(base_dir=base_dir),
+        "@reset": ResetContextProvider(base_dir=base_dir),
+    }
+
+
+class ContextOptionsRequest(BaseModel):
+    """Request for context options."""
+
+    partial_command: Optional[str] = None  # e.g., "@file:src/"
+    base_dir: Optional[str] = None  # Base directory for file resolution
+
+
+class FileContentRequest(BaseModel):
+    """Request to get file content."""
+
+    filepath: str
+    base_dir: Optional[str] = None
+
+
+class FileContentResponse(BaseModel):
+    """Response with file content."""
+
+    content: str
+    filepath: str
+    error: Optional[str] = None
+
+
+@router.get("/autocomplete", response_model=ListOptionsResponse)
+async def get_autocomplete_options(
+    partial_command: Optional[str] = Query(None, alias="partialCommand"),
+    base_dir: Optional[str] = Query(None, alias="baseDir"),
+) -> ListOptionsResponse:
+    """
+    Get autocomplete options for context commands.
+
+    Query Parameters:
+        partialCommand: Partial command to complete
+            - "@" -> list all available commands
+            - "@fi" -> list commands starting with "@fi"
+            - "@file:" -> list files in current directory
+            - "@file:src/" -> list files in src directory
+        baseDir: Base directory for file resolution (default: cwd)
+    """
+    base_directory = base_dir or os.getcwd()
+    providers = _get_all_providers(base_directory)
+
+    if not partial_command:
+        # Return all available context commands
+        options = [p.get_provider_option() for p in providers.values()]
+        return ListOptionsResponse(options=options)
+
+    # Check if it's just "@" or a partial command name (no colon)
+    if ":" not in partial_command:
+        # Filter providers that match the partial command
+        options = []
+        for cmd_id, provider in providers.items():
+            if cmd_id.startswith(partial_command):
+                options.append(provider.get_provider_option())
+        return ListOptionsResponse(options=options)
+
+    # Has colon - parse the partial command
+    cmd_id, _, arg_prefix = partial_command.partition(":")
+
+    # Find matching provider
+    if cmd_id in providers:
+        provider = providers[cmd_id]
+        if provider.requires_arg:
+            options = provider.get_arg_options(arg_prefix)
+            return ListOptionsResponse(options=options)
+        else:
+            # For commands without args (like @reset), return the command itself
+            return ListOptionsResponse(options=[provider.get_provider_option()])
+
+    # No matching provider
+    return ListOptionsResponse(options=[])
+
+
+@router.post("/file/content", response_model=FileContentResponse)
+async def get_file_content(request: FileContentRequest) -> FileContentResponse:
+    """
+    Get the content of a file for context injection.
+
+    This is used when processing @file commands to include file contents
+    in the LLM prompt.
+    """
+    try:
+        base_directory = request.base_dir or os.getcwd()
+        file_provider = FileContextProvider(base_dir=base_directory)
+
+        # Create a command object
+        from agent_server.context_providers.base import ContextCommand
+
+        cmd = ContextCommand(cmd=f"@file:{request.filepath}")
+        content = file_provider.make_context(cmd)
+
+        return FileContentResponse(
+            content=content,
+            filepath=request.filepath,
+        )
+    except Exception as e:
+        logger.error(f"Failed to read file {request.filepath}: {e}")
+        return FileContentResponse(
+            content="",
+            filepath=request.filepath,
+            error=str(e),
+        )
+
+
+@router.get("/providers")
+async def list_context_providers():
+    """
+    List all available context providers.
+
+    Returns information about each context provider including:
+    - ID (e.g., "@file")
+    - Description
+    - Whether it requires an argument
+    - Whether it's an action command
+    """
+    providers = [
+        {
+            "id": "@file",
+            "description": "Include file contents in the prompt",
+            "requires_arg": True,
+            "is_action": False,
+            "usage": "@file:path/to/file.py",
+            "examples": [
+                "@file:main.py",
+                "@file:src/utils.py",
+                "@file:'path with spaces/file.py'",
+            ],
+        },
+        {
+            "id": "@reset",
+            "description": "Clear session and reset agent",
+            "requires_arg": False,
+            "is_action": True,
+            "usage": "@reset",
+            "examples": ["@reset"],
+        },
+    ]
+
+    return {"providers": providers}