agentkernel 0.6.0__tar.gz → 0.6.1__tar.gz

{agentkernel-0.6.0 → agentkernel-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: agentkernel
-Version: 0.6.0
+Version: 0.6.1
 Summary: Agent Kernel - Unified AI Agents Runtime
 Author: Yaala Labs
 Author-email: Yaala Labs <agentkernel@yaalalabs.com>
@@ -12,18 +12,18 @@ Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: singleton-type>=0.0.5
 Requires-Dist: a2a-sdk[http-server]>=0.3.6 ; extra == 'a2a'
 Requires-Dist: google-adk>=1.14.1 ; extra == 'adk'
-Requires-Dist: litellm~=1.74.3 ; extra == 'adk'
+Requires-Dist: litellm~=1.89.2 ; extra == 'adk'
 Requires-Dist: openinference-instrumentation-google-adk>=0.1.6 ; extra == 'adk'
 Requires-Dist: fastapi>=0.118.0 ; extra == 'api'
 Requires-Dist: uvicorn>=0.37.0 ; extra == 'api'
 Requires-Dist: gunicorn>=23.0.0 ; extra == 'api'
-Requires-Dist: pyjwt>=2.0.0 ; extra == 'auth'
+Requires-Dist: pyjwt>=2.13.0 ; extra == 'auth'
 Requires-Dist: boto3>=1.41.4 ; extra == 'aws'
 Requires-Dist: azure-functions>=1.24.0 ; extra == 'azure'
 Requires-Dist: azure-data-tables>=12.4.0 ; extra == 'azure'
 Requires-Dist: azure-core>=1.26.0 ; extra == 'azure'
 Requires-Dist: chromadb>=0.4.0 ; extra == 'chromadb'
-Requires-Dist: crewai>=0.150.0 ; extra == 'crewai'
+Requires-Dist: crewai>=1.15.0 ; extra == 'crewai'
 Requires-Dist: openinference-instrumentation-crewai>=0.1.16 ; extra == 'crewai'
 Requires-Dist: openinference-instrumentation-litellm>=0.1.28 ; extra == 'crewai'
 Requires-Dist: google-cloud-firestore>=2.19.0 ; extra == 'gcp'
@@ -36,15 +36,15 @@ Requires-Dist: langfuse>=4.2.0 ; extra == 'langfuse'
 Requires-Dist: nest-asyncio>=1.6.0 ; extra == 'langfuse'
 Requires-Dist: langgraph~=1.0.5 ; extra == 'langgraph'
 Requires-Dist: langchain~=1.2.3 ; extra == 'langgraph'
-Requires-Dist: langchain-community~=0.4.1 ; extra == 'langgraph'
-Requires-Dist: litellm~=1.74.9 ; extra == 'langgraph'
+Requires-Dist: langchain-community==0.4.1 ; extra == 'langgraph'
+Requires-Dist: litellm~=1.89.2 ; extra == 'langgraph'
 Requires-Dist: fastmcp>=2.14.2,<3.0.0 ; extra == 'mcp'
 Requires-Dist: httpx>=0.27.0 ; extra == 'messenger'
 Requires-Dist: neo4j>=5.0.0 ; extra == 'neo4j'
 Requires-Dist: openai-agents>=0.6.5 ; extra == 'openai'
 Requires-Dist: openinference-instrumentation-openai-agents>=1.4.0 ; extra == 'openai'
 Requires-Dist: openai-guardrails>=0.2.1 ; extra == 'openai'
-Requires-Dist: traceloop-sdk>=0.48.0 ; extra == 'openllmetry'
+Requires-Dist: traceloop-sdk>=0.61.0 ; extra == 'openllmetry'
 Requires-Dist: redis>=7.1.0 ; extra == 'redis'
 Requires-Dist: slack-bolt==1.22.0 ; extra == 'slack'
 Requires-Dist: httpx>=0.27.0 ; extra == 'slack'
@@ -63,7 +63,7 @@ Requires-Dist: rapidfuzz>=3.14.1 ; extra == 'test'
 Requires-Dist: ragas>=0.4.1 ; extra == 'test'
 Requires-Dist: datasets>=2.14.0 ; extra == 'test'
 Requires-Dist: pandas>=2.0.0 ; extra == 'test'
-Requires-Dist: litellm>=1.74.9 ; extra == 'test'
+Requires-Dist: litellm>=1.89.2 ; extra == 'test'
 Requires-Dist: trino>=0.337.0 ; extra == 'trino'
 Requires-Dist: walledai>=4.9.3 ; extra == 'walledai'
 Requires-Dist: httpx>=0.27.0 ; extra == 'whatsapp'

{agentkernel-0.6.0 → agentkernel-0.6.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "agentkernel"
-version = "0.6.0"
+version = "0.6.1"
 description = "Agent Kernel - Unified AI Agents Runtime"
 readme = "README.md"
 requires-python = ">=3.12,<3.14"
@@ -22,25 +22,25 @@ dependencies = [
 
 [project.optional-dependencies]
 auth = [
-    "PyJWT>=2.0.0",
+    "PyJWT>=2.13.0",
 ]
 langfuse = [
     "langfuse>=4.2.0",
     "nest-asyncio>=1.6.0",
 ]
 openllmetry = [
-    "traceloop-sdk>=0.48.0",
+    "traceloop-sdk>=0.61.0",
 ]
 crewai = [
-    "crewai>=0.150.0",
+    "crewai>=1.15.0",
     "openinference-instrumentation-crewai>=0.1.16",
     "openinference-instrumentation-litellm>=0.1.28",
 ]
 langgraph = [
     "langgraph~=1.0.5",
     "langchain~=1.2.3",
-    "langchain_community~=0.4.1",
-    "litellm~=1.74.9"
+    "langchain_community==0.4.1",
+    "litellm~=1.89.2"
 ]
 smolagents = [
     "smolagents>=1.0.0",
@@ -78,7 +78,7 @@ openai = [
 ]
 adk = [
     "google-adk>=1.14.1",
-    "litellm~=1.74.3",
+    "litellm~=1.89.2",
     "openinference-instrumentation-google-adk>=0.1.6",
 ]
 walledai = [
@@ -130,7 +130,7 @@ test = [
     "ragas>=0.4.1",
     "datasets>=2.14.0",
     "pandas>=2.0.0",
-    "litellm>=1.74.9",
+    "litellm>=1.89.2",
 ]
 a2a = [
     "a2a-sdk[http-server]>=0.3.6",
@@ -144,7 +144,7 @@ ak = "agentkernel.cli.ak:main"
 
 [dependency-groups]
 dev = [
-    "black>=23.0.0",
+    "black==26.5.1",
     "isort>=5.0.0",
     "mypy>=1.0.0",
 ]

{agentkernel-0.6.0 → agentkernel-0.6.1}/src/agentkernel/api/handler.py

@@ -2,12 +2,13 @@ import logging
 from abc import ABC, abstractmethod
 from typing import List, Optional
 
-from fastapi import APIRouter, File, Form, UploadFile
+from fastapi import APIRouter, File, Form, HTTPException, UploadFile
+from fastapi.responses import StreamingResponse
 from pydantic import ConfigDict
 
 from ..core import Config
 from ..core.chat_service import ChatService
-from ..core.model import BaseChatRequest, BaseRunRequest
+from ..core.model import BaseChatRequest, BaseRunRequest, ExecutionMode
 from ..core.runtime import Runtime
 
 
@@ -35,8 +36,8 @@ class AgentRESTRequestHandler(RESTRequestHandler):
     API routers that expose endpoints to interact with Agent Kernel.
     Endpoints:
     - GET /api/v1/agents: List available agents
-    - POST /api/v1/chat: Run an agent with a prompt
-      Payload JSON: { "prompt": str, "agent": str | null, "session_id": str | null }
+    - POST /api/v1/chat: Run an agent (streams SSE when execution.mode=stream, otherwise returns JSON)
+    - POST /api/v1/chat-multipart: Same as /api/v1/chat but accepts multipart form data with file/image uploads
     """
 
     class BaseMultimodalRunRequest(BaseChatRequest):
@@ -64,6 +65,14 @@ class AgentRESTRequestHandler(RESTRequestHandler):
 
         @router.post("/api/v1/chat")
         async def run(body: BaseRunRequest):
+            if Config.get().execution.mode == ExecutionMode.STREAM:
+                try:
+                    gen = await self.chat_service.process_stream_chat_async(req=body, sse_format=True)
+                    return StreamingResponse(gen, media_type="text/event-stream")
+                except ValueError as e:
+                    raise HTTPException(status_code=400, detail=str(e))
+                except Exception as e:
+                    raise HTTPException(status_code=500, detail=f"Streaming failed: {str(e)}")
             return await self.chat_service.process_async_chat_request(req=body)
 
         @router.post("/api/v1/chat-multipart")
@@ -74,7 +83,6 @@ class AgentRESTRequestHandler(RESTRequestHandler):
             files: Optional[List[UploadFile]] = File(None),
             images: Optional[List[UploadFile]] = File(None),
         ):
-            # Construct BaseMultimodalRunRequest from form parameters
             req = AgentRESTRequestHandler.BaseMultimodalRunRequest(
                 prompt=prompt,
                 agent=agent,
@@ -82,6 +90,14 @@ class AgentRESTRequestHandler(RESTRequestHandler):
                 files=files,
                 images=images,
             )
+            if Config.get().execution.mode == ExecutionMode.STREAM:
+                try:
+                    gen = await self.chat_service.process_stream_chat_async(req=req, sse_format=True)
+                    return StreamingResponse(gen, media_type="text/event-stream")
+                except ValueError as e:
+                    raise HTTPException(status_code=400, detail=str(e))
+                except Exception as e:
+                    raise HTTPException(status_code=500, detail=f"Streaming failed: {str(e)}")
             return await self.chat_service.process_async_chat_request(req=req)
 
         return router

{agentkernel-0.6.0 → agentkernel-0.6.1}/src/agentkernel/api/http.py

@@ -72,7 +72,10 @@ class RESTAPI:
         """
         cls._log.debug(f"Adding custom router")
         for route in router.routes:
-            cls._log.debug(f"Route: {route.path} [{route.methods}]")
+            route_path = getattr(route, "path", None)
+            route_methods = getattr(route, "methods", None)
+            if route_path is not None:
+                cls._log.debug(f"Route: {route_path} [{route_methods}]")
         cls._custom_routers.append(router)
 
     @classmethod

{agentkernel-0.6.0 → agentkernel-0.6.1}/src/agentkernel/core/__init__.py

@@ -21,6 +21,7 @@ from .model import (
     AgentReply,
     AgentReplyText,
     AgentReplyImage,
+    StreamChunk,
 )
 from .config import AKConfig as Config
 from .module import Module

{agentkernel-0.6.0 → agentkernel-0.6.1}/src/agentkernel/core/base.py

@@ -2,7 +2,7 @@ import asyncio
 import contextvars
 import logging
 from abc import ABC, abstractmethod
-from collections.abc import Iterator
+from collections.abc import AsyncGenerator, Iterator
 from enum import Enum
 from typing import Any, ClassVar, Self, cast
 
@@ -231,6 +231,17 @@ class Runner(ABC):
         """
         raise NotImplementedError()
 
+    @abstractmethod
+    async def stream(self, agent: Any, session: Session, requests: list[AgentRequest]) -> AsyncGenerator[str, None]:
+        """
+        Streams the agent response token by token.
+        :param agent: The agent to run.
+        :param session: The session to use for the agent.
+        :param requests: The list of requests to provide to the agent.
+        :return: An async generator yielding string token deltas.
+        """
+        raise NotImplementedError()
+
 
 class Agent(ABC):
     """

{agentkernel-0.6.0 → agentkernel-0.6.1}/src/agentkernel/core/chat_service.py

@@ -1,6 +1,8 @@
 import asyncio
 import base64
+import json
 import logging
+from collections.abc import AsyncGenerator, Generator
 from typing import Any, Dict, List, Optional, Union
 
 from .config import AKConfig
@@ -13,6 +15,7 @@ from .model import (
     AgentRequestText,
     BaseChatRequest,
     BaseRunRequest,
+    StreamChunk,
 )
 from .service import AgentService
 
@@ -194,21 +197,30 @@ class AgentHandler:
         if not self.service.agent:
             raise ValueError("No agent available")
 
-    def run_sync(self, requests: List[Any]) -> Any:
-        """Run agent requests synchronously.
+    @staticmethod
+    def _run_async_sync(coro) -> Any:
+        """Run an async coroutine from sync code, handling event loop state.
 
-        :param requests: List of AgentRequest objects to process
-        :return: Agent execution result
+        :param coro: Coroutine to execute
+        :return: Result of the coroutine
         """
         try:
             loop = asyncio.get_event_loop()
             if loop.is_closed():
                 asyncio.set_event_loop(asyncio.new_event_loop())
-                return asyncio.run(self.service.run_multi(requests=requests))
+                return asyncio.run(coro)
             else:
-                return loop.run_until_complete(self.service.run_multi(requests=requests))
+                return loop.run_until_complete(coro)
         except RuntimeError:
-            return asyncio.run(self.service.run_multi(requests=requests))
+            return asyncio.run(coro)
+
+    def run_sync(self, requests: List[Any]) -> Any:
+        """Run agent requests synchronously.
+
+        :param requests: List of AgentRequest objects to process
+        :return: Agent execution result
+        """
+        return AgentHandler._run_async_sync(self.service.run_multi(requests=requests))
 
     async def run_async(self, requests: List[Any]) -> Any:
         """Run agent requests asynchronously.
@@ -218,6 +230,32 @@ class AgentHandler:
         """
         return await self.service.run_multi(requests=requests)
 
+    def run_stream_sync(self, requests: List[Any]) -> List[Any]:
+        """Run agent streaming requests synchronously.
+
+        Manages event loop lifecycle internally and returns all chunks as a list.
+
+        :param requests: List of AgentRequest objects to process
+        :return: List of StreamChunk objects
+        """
+
+        async def _collect():
+            chunks = []
+            async for chunk in self.service.stream_multi(requests=requests):
+                chunks.append(chunk)
+            return chunks
+
+        return AgentHandler._run_async_sync(_collect())
+
+    async def run_stream_async(self, requests: List[Any]) -> AsyncGenerator[Any, None]:
+        """Run agent streaming requests asynchronously.
+
+        :param requests: List of AgentRequest objects to process
+        :return: AsyncGenerator yielding StreamChunk objects
+        """
+        async for chunk in self.service.stream_multi(requests=requests):
+            yield chunk
+
     def get_response_session_id(self, session_id: Optional[str]) -> Optional[str]:
         """Get the session ID for the response.
 
@@ -231,40 +269,44 @@ class ResponseBuilder:
     """Formats agent results and errors into response dicts."""
 
     @staticmethod
-    def success(status_code: int, result: Any, session_id: str, rest_api_mode: bool):
-        """Build success response from agent result.
+    def build_response(status_code: int, session_id: Optional[str], rest_api_mode: bool, result: Any = None, error: Optional[Exception] = None):
+        """Build response from agent result or error.
 
-        :param status_code: HTTP status code for success
-        :param result: Agent execution result
+        :param status_code: HTTP status code
         :param session_id: Session identifier for the response
-        :param rest_api_mode: If True, return dict only; if False, return tuple
-        :return: Response dict or (status_code, response_dict) tuple
+        :param rest_api_mode: If True, return dict only on success or raise HTTPException on error; if False, return tuple
+        :param result: Agent execution result (mutually exclusive with error)
+        :param error: Exception that occurred (mutually exclusive with result)
+        :return: Response dict or (status_code, response_dict) tuple; raises HTTPException if error in rest_api_mode
         """
-        response_dict = {
-            "result": str(result) if isinstance(result, (AgentReplyText, AgentReplyImage)) else "Non textual result received",
-            "session_id": session_id,
-        }
-        return response_dict if rest_api_mode else (status_code, response_dict)
+        if error:
+            response_dict = {"error": str(error)}
+        else:
+            response_dict = {"result": str(result) if isinstance(result, (AgentReplyText, AgentReplyImage)) else "Non textual result received"}
 
-    @staticmethod
-    def error(status_code: int, error: Exception, session_id: Optional[str], rest_api_mode: bool):
-        """Build error response from exception.
+        if session_id:
+            response_dict["session_id"] = session_id
 
-        :param status_code: HTTP status code for error
-        :param error: Exception that occurred
-        :param session_id: Session identifier for the response
-        :param rest_api_mode: If True, raise HTTPException; if False, return tuple
-        :return: (status_code, response_dict) tuple or raises HTTPException
-        """
-        response_dict = {
-            "error": str(error),
-            "session_id": session_id,
-        }
-        if rest_api_mode:
+        if error and rest_api_mode:
             from fastapi import HTTPException
 
             raise HTTPException(status_code=status_code, detail=response_dict)
-        return (status_code, response_dict)
+
+        return response_dict if rest_api_mode else (status_code, response_dict)
+
+    @staticmethod
+    def stream_chunk(chunk: StreamChunk, session_id: str, sse_format: bool = False) -> str:
+        """Format a StreamChunk as JSON or SSE.
+
+        :param chunk: StreamChunk to format
+        :param session_id: Session identifier to include in the payload
+        :param sse_format: When True, wrap the JSON payload as an SSE frame.
+        :return: JSON string or SSE-formatted string with excluded None values
+        """
+        payload_dict = chunk.model_dump(exclude_none=True)
+        payload_dict["session_id"] = session_id
+        payload = json.dumps(payload_dict)
+        return f"data: {payload}\n\n" if sse_format else payload
 
 
 class ChatService:
@@ -291,13 +333,13 @@ class ChatService:
             requests = RequestBuilder.from_base_request_sync(req)
             handler.initialize(session_id, req.agent)
             result = handler.run_sync(requests)
-            return ResponseBuilder.success(200, result, handler.get_response_session_id(session_id), self.rest_api_mode)
+            return ResponseBuilder.build_response(200, handler.get_response_session_id(session_id), self.rest_api_mode, result=result)
         except ValueError as ve:
             self._log.error(f"ValueError processing request: {ve}")
-            return ResponseBuilder.error(400, ve, handler.get_response_session_id(session_id), self.rest_api_mode)
+            return ResponseBuilder.build_response(400, handler.get_response_session_id(session_id), self.rest_api_mode, error=ve)
         except Exception as e:
             self._log.error(f"Error processing request: {e}")
-            return ResponseBuilder.error(500, e, handler.get_response_session_id(None), self.rest_api_mode)
+            return ResponseBuilder.build_response(500, handler.get_response_session_id(None), self.rest_api_mode, error=e)
 
     async def process_async_chat_request(self, req: BaseChatRequest) -> Union[tuple[int, Dict[str, Any]], Dict[str, Any]]:
         """Process a chat request asynchronously.
@@ -317,13 +359,83 @@ class ChatService:
             requests = await RequestBuilder.from_base_request_async(req)
             handler.initialize(session_id, req.agent)
             result = await handler.run_async(requests)
-            return ResponseBuilder.success(200, result, handler.get_response_session_id(session_id), self.rest_api_mode)
+            return ResponseBuilder.build_response(200, handler.get_response_session_id(session_id), self.rest_api_mode, result=result)
         except ValueError as ve:
             self._log.error(f"ValueError processing request: {ve}")
-            return ResponseBuilder.error(400, ve, handler.get_response_session_id(session_id), self.rest_api_mode)
+            return ResponseBuilder.build_response(400, handler.get_response_session_id(session_id), self.rest_api_mode, error=ve)
         except Exception as e:
             self._log.error(f"Error processing request: {e}")
-            return ResponseBuilder.error(500, e, handler.get_response_session_id(session_id), self.rest_api_mode)
+            return ResponseBuilder.build_response(500, handler.get_response_session_id(session_id), self.rest_api_mode, error=e)
+
+    async def process_stream_chat_async(
+        self,
+        req: BaseChatRequest,
+        sse_format: bool = False,
+    ) -> AsyncGenerator[str, None]:
+        """Process a streaming chat request asynchronously.
+
+        Validate, initialize, and return a streaming chat response generator.
+
+        :param req: Base chat request with prompt, session_id, agent, and optional attachments
+        :param sse_format: When True, yield Server-Sent Events formatted frames.
+                           When False, yield raw StreamChunk JSON payloads.
+        :return: Async generator yielding StreamChunk payloads as JSON or SSE-formatted strings
+        :raises ValueError: If session_id or prompt is missing, or no agent is available
+        """
+        session_id = req.session_id
+        if not session_id:
+            raise ValueError("No session_id is provided in the request")
+        if not req.prompt:
+            raise ValueError("No prompt provided in the request")
+        requests = await RequestBuilder.from_base_request_async(req)
+        handler = AgentHandler()
+        handler.initialize(session_id, req.agent)
+
+        async def _stream() -> AsyncGenerator[str, None]:
+            try:
+                async for chunk in handler.run_stream_async(requests):
+                    yield ResponseBuilder.stream_chunk(chunk, session_id, sse_format=sse_format)
+            except Exception as e:
+                error_chunk = StreamChunk(error=str(e), done=True)
+                yield ResponseBuilder.stream_chunk(error_chunk, session_id, sse_format=sse_format)
+
+        return _stream()
+
+    def process_stream_chat_sync(
+        self,
+        req: BaseRunRequest,
+        sse_format: bool = False,
+    ) -> Generator[str, None, None]:
+        """Process a streaming chat request synchronously.
+
+        Validates and initializes eagerly (before returning the generator), then
+        yields formatted streaming chunks. Mirrors the async version's pattern so
+        ValueError is raised at call time, not deferred until the first iteration.
+
+        :param req: Base run request with prompt, session_id, agent, and attachments
+        :param sse_format: When True, yield Server-Sent Events formatted frames.
+                           When False, yield raw StreamChunk JSON payloads.
+        :return: Generator yielding StreamChunk payloads as JSON or SSE-formatted strings
+        :raises ValueError: If session_id or prompt is missing, or no agent is available
+        """
+        session_id = req.session_id
+        if not session_id:
+            raise ValueError("No session_id is provided in the request")
+        if not req.prompt:
+            raise ValueError("No prompt provided in the request")
+        requests = RequestBuilder.from_base_request_sync(req)
+        handler = AgentHandler()
+        handler.initialize(session_id, req.agent)
+
+        def _stream() -> Generator[str, None, None]:
+            try:
+                for chunk in handler.run_stream_sync(requests):
+                    yield ResponseBuilder.stream_chunk(chunk, session_id, sse_format=sse_format)
+            except Exception as e:
+                error_chunk = StreamChunk(error=str(e), done=True)
+                yield ResponseBuilder.stream_chunk(error_chunk, session_id, sse_format=sse_format)
+
+        return _stream()
 
     @staticmethod
     def _validate(req: BaseRunRequest):

{agentkernel-0.6.0 → agentkernel-0.6.1}/src/agentkernel/core/config.py

@@ -286,7 +286,7 @@ class _LoggingConfig(BaseModel):
 class _ExecutionConfig(BaseModel):
     mode: Optional[ExecutionMode] = Field(
         default=None,
-        description="Execution mode: rest_sync for synchronous REST, rest_async for asynchronous REST",
+        description="Execution mode: rest_sync for synchronous REST, rest_async for asynchronous REST, stream for token streaming (WebSocket serverless or containerized direct streaming)",
     )
     queues: Optional[_QueuesConfig] = Field(default_factory=_QueuesConfig, description="Queue URLs for async execution mode")
     response_store: Optional[_ResponseStoreConfig] = Field(

{agentkernel-0.6.0 → agentkernel-0.6.1}/src/agentkernel/core/hooks.py

@@ -67,6 +67,20 @@ class PostHook(ABC):
         """
         raise NotImplementedError
 
+    async def on_stream_chunk(
+        self,
+        session: "Session",
+        requests: list[AgentRequest],
+        agent: "Agent",
+        delta: str,
+    ) -> str | None:
+        """
+        Called for each streaming token delta before it is sent to the client.
+        Return the (optionally modified) delta string, or None to drop the token.
+        Default implementation passes the delta through unchanged.
+        """
+        return delta
+
     @abstractmethod
     def name(self) -> str:
         """

{agentkernel-0.6.0 → agentkernel-0.6.1}/src/agentkernel/core/model.py

@@ -119,6 +119,12 @@ class ExecutionMode(str, Enum):
     ASYNC = "async"
 
 
+class StreamChunk(BaseModel):
+    delta: str | None = None
+    done: bool = False
+    error: str | None = None
+
+
 class SystemTool(BaseModel):
     name: str
     description: str

{agentkernel-0.6.0 → agentkernel-0.6.1}/src/agentkernel/core/multimodal/storage/dynamodb.py

@@ -183,4 +183,8 @@ class DynamoDBAttachmentStore(AttachmentStore):
         :param attachment_id: Attachment ID.
         """
         self._driver.delete(self._session_id, attachment_id)
+        index_ids = self._driver.get(self._session_id, "_index") or []
+        if attachment_id in index_ids:
+            index_ids.remove(attachment_id)
+            self._driver.put(self._session_id, "_index", index_ids)
         self._log.debug(f"Deleted attachment: {attachment_id}")

{agentkernel-0.6.0 → agentkernel-0.6.1}/src/agentkernel/core/multimodal/storage/redis.py

@@ -97,8 +97,9 @@ class RedisAttachmentDriver:
         return None
 
     def delete(self, session_id: str, attachment_id: str) -> None:
-        """Delete a single attachment."""
+        """Delete a single attachment and remove its ID from the session index."""
         self.client.delete(self.key(session_id, attachment_id))
+        self.client.lrem(self.index_key(session_id), 0, attachment_id)
 
     def append_index(self, session_id: str, attachment_id: str) -> None:
         """Append an attachment ID to the session index."""

{agentkernel-0.6.0 → agentkernel-0.6.1}/src/agentkernel/core/multimodal/storage/session_cache.py

@@ -72,3 +72,7 @@ class SessionNonVolatileCacheAttachmentStore(AttachmentStore):
 
     def delete(self, attachment_id: str) -> None:
         self._cache.delete(f"{ATTACHMENT_KEY_PREFIX}{attachment_id}")
+        index = self._cache.get(ATTACHMENT_INDEX_KEY)
+        if index and attachment_id in index["ids"]:
+            index["ids"].remove(attachment_id)
+            self._cache.set(ATTACHMENT_INDEX_KEY, index)