agent-runtime-core 0.6.0__py3-none-any.whl → 0.7.1__py3-none-any.whl

agent_runtime_core/vectorstore/vertex.py

@@ -0,0 +1,295 @@
+"""
+Vertex AI Vector Search implementation.
+
+Uses Google Cloud Vertex AI Vector Search for enterprise-scale vector similarity search.
+Ideal for production deployments requiring managed infrastructure and high scalability.
+
+Requires: pip install google-cloud-aiplatform
+
+Note: Vertex AI Vector Search requires pre-created index and endpoint resources.
+See: https://cloud.google.com/vertex-ai/docs/vector-search/overview
+"""
+
+import json
+from typing import Optional
+
+from agent_runtime_core.vectorstore.base import (
+    VectorStore,
+    VectorRecord,
+    VectorSearchResult,
+)
+
+
+class VertexVectorStore(VectorStore):
+    """
+    Vector store using Google Vertex AI Vector Search.
+
+    This implementation uses Vertex AI's managed vector search service for
+    enterprise-scale similarity search. It's ideal for:
+    - Production deployments requiring high availability
+    - Large-scale datasets (billions of vectors)
+    - Applications already using Google Cloud
+
+    Important: This store requires pre-created Vertex AI resources:
+    1. A Vector Search Index
+    2. An Index Endpoint with the index deployed
+
+    The store maintains a local cache of content/metadata since Vertex AI
+    Vector Search only stores vectors and IDs. For production use, consider
+    using a separate database for content storage.
+    """
+
+    def __init__(
+        self,
+        project_id: str,
+        location: str,
+        index_endpoint_id: str,
+        deployed_index_id: str,
+        index_id: Optional[str] = None,
+    ):
+        """
+        Initialize Vertex AI Vector Search store.
+
+        Args:
+            project_id: Google Cloud project ID
+            location: Google Cloud region (e.g., "us-central1")
+            index_endpoint_id: The ID of the index endpoint
+            deployed_index_id: The ID of the deployed index
+            index_id: Optional index ID for batch updates
+        """
+        self._project_id = project_id
+        self._location = location
+        self._index_endpoint_id = index_endpoint_id
+        self._deployed_index_id = deployed_index_id
+        self._index_id = index_id
+        self._endpoint = None
+        self._initialized = False
+
+        # Local cache for content and metadata
+        # In production, use a proper database
+        self._content_cache: dict[str, tuple[str, dict]] = {}
+
+    def _ensure_initialized(self) -> None:
+        """Initialize Vertex AI SDK and get endpoint."""
+        if self._initialized:
+            return
+        try:
+            from google.cloud import aiplatform
+            from google.cloud.aiplatform.matching_engine import MatchingEngineIndexEndpoint
+        except ImportError:
+            raise ImportError(
+                "Google Cloud AI Platform package not installed. "
+                "Install with: pip install google-cloud-aiplatform"
+            )
+
+        aiplatform.init(project=self._project_id, location=self._location)
+
+        # Get the index endpoint
+        endpoint_resource_name = (
+            f"projects/{self._project_id}/locations/{self._location}/"
+            f"indexEndpoints/{self._index_endpoint_id}"
+        )
+        self._endpoint = MatchingEngineIndexEndpoint(endpoint_resource_name)
+        self._initialized = True
+
+    async def add(
+        self,
+        id: str,
+        vector: list[float],
+        content: str,
+        metadata: Optional[dict] = None,
+    ) -> None:
+        """
+        Add a vector with its content and metadata.
+
+        Note: For Vertex AI, vectors are typically added through batch operations
+        to the index. This method adds to a local cache and should be followed
+        by a batch update to the index.
+        """
+        self._ensure_initialized()
+
+        # Store content and metadata locally
+        self._content_cache[id] = (content, metadata or {})
+
+        # For single adds, we use the streaming update API if available
+        # This requires the index to support streaming updates
+        if self._index_id:
+            import asyncio
+            from google.cloud import aiplatform
+
+            index_resource_name = (
+                f"projects/{self._project_id}/locations/{self._location}/"
+                f"indexes/{self._index_id}"
+            )
+            index = aiplatform.MatchingEngineIndex(index_resource_name)
+
+            # Prepare datapoint
+            datapoint = {
+                "datapoint_id": id,
+                "feature_vector": vector,
+            }
+
+            # Run in executor since SDK is synchronous
+            loop = asyncio.get_event_loop()
+            await loop.run_in_executor(
+                None,
+                lambda: index.upsert_datapoints(datapoints=[datapoint]),
+            )
+
+    async def add_batch(
+        self,
+        items: list[tuple[str, list[float], str, Optional[dict]]],
+    ) -> None:
+        """Add multiple vectors efficiently."""
+        if not items:
+            return
+
+        self._ensure_initialized()
+
+        # Store content and metadata locally
+        for id, _, content, metadata in items:
+            self._content_cache[id] = (content, metadata or {})
+
+        if self._index_id:
+            import asyncio
+            from google.cloud import aiplatform
+
+            index_resource_name = (
+                f"projects/{self._project_id}/locations/{self._location}/"
+                f"indexes/{self._index_id}"
+            )
+            index = aiplatform.MatchingEngineIndex(index_resource_name)
+
+            # Prepare datapoints
+            datapoints = [
+                {"datapoint_id": id, "feature_vector": vector}
+                for id, vector, _, _ in items
+            ]
+
+            # Run in executor since SDK is synchronous
+            loop = asyncio.get_event_loop()
+            await loop.run_in_executor(
+                None,
+                lambda: index.upsert_datapoints(datapoints=datapoints),
+            )
+
+    async def search(
+        self,
+        query_vector: list[float],
+        limit: int = 10,
+        filter: Optional[dict] = None,
+    ) -> list[VectorSearchResult]:
+        """Search for similar vectors."""
+        self._ensure_initialized()
+        import asyncio
+
+        # Vertex AI Vector Search uses find_neighbors for queries
+        loop = asyncio.get_event_loop()
+
+        # Build the query
+        queries = [query_vector]
+
+        # Execute search
+        response = await loop.run_in_executor(
+            None,
+            lambda: self._endpoint.find_neighbors(
+                deployed_index_id=self._deployed_index_id,
+                queries=queries,
+                num_neighbors=limit,
+            ),
+        )
+
+        results = []
+        if response and len(response) > 0:
+            for neighbor in response[0]:
+                id = neighbor.id
+                # Vertex AI returns distance, convert to similarity
+                # Using cosine similarity: score = 1 - distance for normalized vectors
+                score = 1.0 - neighbor.distance if hasattr(neighbor, "distance") else 0.0
+
+                # Get content and metadata from cache
+                content, metadata = self._content_cache.get(id, ("", {}))
+
+                # Apply filter if provided
+                if filter:
+                    match = all(
+                        metadata.get(k) == v for k, v in filter.items()
+                    )
+                    if not match:
+                        continue
+
+                results.append(
+                    VectorSearchResult(
+                        id=id,
+                        content=content,
+                        score=score,
+                        metadata=metadata,
+                    )
+                )
+
+        return results
+
+    async def delete(self, id: str) -> bool:
+        """Delete a vector by ID."""
+        self._ensure_initialized()
+
+        # Remove from local cache
+        existed = id in self._content_cache
+        self._content_cache.pop(id, None)
+
+        # Delete from index if index_id is provided
+        if self._index_id:
+            import asyncio
+            from google.cloud import aiplatform
+
+            index_resource_name = (
+                f"projects/{self._project_id}/locations/{self._location}/"
+                f"indexes/{self._index_id}"
+            )
+            index = aiplatform.MatchingEngineIndex(index_resource_name)
+
+            loop = asyncio.get_event_loop()
+            await loop.run_in_executor(
+                None,
+                lambda: index.remove_datapoints(datapoint_ids=[id]),
+            )
+
+        return existed
+
+    async def delete_by_filter(self, filter: dict) -> int:
+        """Delete vectors matching filter."""
+        # Find matching IDs from cache
+        ids_to_delete = []
+        for id, (_, metadata) in self._content_cache.items():
+            if all(metadata.get(k) == v for k, v in filter.items()):
+                ids_to_delete.append(id)
+
+        # Delete each matching ID
+        for id in ids_to_delete:
+            await self.delete(id)
+
+        return len(ids_to_delete)
+
+    async def get(self, id: str) -> Optional[VectorRecord]:
+        """
+        Get a vector by ID.
+
+        Note: Vertex AI Vector Search doesn't support direct vector retrieval.
+        This returns cached content/metadata with an empty vector.
+        """
+        if id not in self._content_cache:
+            return None
+
+        content, metadata = self._content_cache[id]
+        return VectorRecord(
+            id=id,
+            vector=[],  # Vertex AI doesn't support vector retrieval
+            content=content,
+            metadata=metadata,
+        )
+
+    async def close(self) -> None:
+        """Close connections."""
+        self._endpoint = None
+        self._initialized = False
+

{agent_runtime_core-0.6.0.dist-info → agent_runtime_core-0.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-runtime-core
-Version: 0.6.0
+Version: 0.7.1
 Summary: Framework-agnostic Python library for executing AI agents with consistent patterns
 Project-URL: Homepage, https://github.com/makemore/agent-runtime-core
 Project-URL: Repository, https://github.com/makemore/agent-runtime-core
@@ -19,10 +19,12 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.11
 Provides-Extra: all
 Requires-Dist: anthropic>=0.18.0; extra == 'all'
+Requires-Dist: google-cloud-aiplatform>=1.38.0; extra == 'all'
 Requires-Dist: langfuse>=2.0.0; extra == 'all'
 Requires-Dist: litellm>=1.0.0; extra == 'all'
 Requires-Dist: openai>=1.0.0; extra == 'all'
 Requires-Dist: redis>=5.0.0; extra == 'all'
+Requires-Dist: sqlite-vec>=0.1.0; extra == 'all'
 Provides-Extra: anthropic
 Requires-Dist: anthropic>=0.18.0; extra == 'anthropic'
 Provides-Extra: dev
@@ -39,6 +41,10 @@ Provides-Extra: openai
 Requires-Dist: openai>=1.0.0; extra == 'openai'
 Provides-Extra: redis
 Requires-Dist: redis>=5.0.0; extra == 'redis'
+Provides-Extra: sqlite-vec
+Requires-Dist: sqlite-vec>=0.1.0; extra == 'sqlite-vec'
+Provides-Extra: vertex
+Requires-Dist: google-cloud-aiplatform>=1.38.0; extra == 'vertex'
 Description-Content-Type: text/markdown
 
 # agent-runtime-core
@@ -53,6 +59,7 @@ A lightweight, framework-agnostic Python library for building AI agent systems.
 
 | Version | Date | Changes |
 |---------|------|---------|
+| **0.7.1** | 2026-01-24 | RAG module, vector stores (sqlite-vec, Vertex AI), memory system, multi-agent support, agentic loop, JSON runtime |
 | **0.6.0** | 2025-01-23 | Enhanced registry with factory functions and class registration |
 | **0.5.2** | 2025-01-14 | Add ToolCallingAgent base class, execute_with_events helper |
 | **0.5.1** | 2025-01-13 | Bug fixes and improvements |
@@ -820,6 +827,200 @@ The executor emits events for observability:
 - `EventType.STEP_SKIPPED` - Step skipped (already completed)
 - `EventType.PROGRESS_UPDATE` - Progress percentage update
 
+## Multi-Agent Systems
+
+The `multi_agent` module provides the "agent-as-tool" pattern, allowing agents to invoke other agents as tools. This enables router/dispatcher patterns, hierarchical agent systems, and specialist delegation.
+
+### Core Concepts
+
+**Invocation Modes:**
+- `DELEGATE`: Sub-agent runs and returns result to parent (parent continues). Good for "get me an answer".
+- `HANDOFF`: Control transfers completely to sub-agent (parent exits). Good for "transfer this customer to billing".
+
+**Context Modes:**
+- `FULL`: Complete conversation history passed to sub-agent (default)
+- `SUMMARY`: Summarized context + current message (more efficient)
+- `MESSAGE_ONLY`: Only the invocation message (clean isolation)
+
+### Creating Agent Tools
+
+Wrap any agent as a tool that can be called by other agents:
+
+```python
+from agent_runtime_core.multi_agent import (
+    AgentTool,
+    InvocationMode,
+    ContextMode,
+    invoke_agent,
+    register_agent_tools,
+)
+
+# Define specialist agents
+class BillingAgent(AgentRuntime):
+    @property
+    def key(self) -> str:
+        return "billing-specialist"
+
+    async def run(self, ctx: RunContext) -> RunResult:
+        # Handle billing questions, refunds, payments
+        ...
+
+class TechSupportAgent(AgentRuntime):
+    @property
+    def key(self) -> str:
+        return "tech-support"
+
+    async def run(self, ctx: RunContext) -> RunResult:
+        # Handle technical issues
+        ...
+
+# Wrap agents as tools
+billing_tool = AgentTool(
+    agent=BillingAgent(),
+    name="billing_specialist",
+    description="Handles billing questions, refunds, and payment issues. Use when customer has billing-related questions.",
+    invocation_mode=InvocationMode.DELEGATE,
+    context_mode=ContextMode.FULL,
+)
+
+tech_support_tool = AgentTool(
+    agent=TechSupportAgent(),
+    name="tech_support",
+    description="Handles technical issues and troubleshooting. Use for technical problems.",
+    invocation_mode=InvocationMode.HANDOFF,  # Transfer control completely
+)
+```
+
+### Router Agent Pattern
+
+Create a router agent that delegates to specialists:
+
+```python
+class RouterAgent(AgentRuntime):
+    """Routes customer requests to appropriate specialist agents."""
+
+    def __init__(self):
+        self.agent_tools = [billing_tool, tech_support_tool]
+
+    @property
+    def key(self) -> str:
+        return "customer-router"
+
+    async def run(self, ctx: RunContext) -> RunResult:
+        from agent_runtime_core.llm import get_llm_client
+        llm = get_llm_client()
+
+        # Create tool registry with agent-tools
+        tools = ToolRegistry()
+        messages = list(ctx.input_messages)
+
+        # Register agent-tools as callable tools
+        register_agent_tools(
+            registry=tools,
+            agent_tools=self.agent_tools,
+            get_conversation_history=lambda: messages,
+            parent_ctx=ctx,
+        )
+
+        # Add system prompt for routing
+        system_message = {
+            "role": "system",
+            "content": """You are a customer service router. Analyze the customer's
+            request and delegate to the appropriate specialist:
+            - billing_specialist: For billing, payments, refunds
+            - tech_support: For technical issues (this will transfer the customer)
+
+            If you can answer directly, do so. Otherwise, use the appropriate tool."""
+        }
+
+        while True:
+            response = await llm.generate(
+                [system_message] + messages,
+                tools=tools.to_openai_format(),
+            )
+
+            messages.append(response.message)
+
+            if not response.tool_calls:
+                # No tool call - respond directly
+                await ctx.emit(EventType.ASSISTANT_MESSAGE, {
+                    "content": response.content,
+                })
+                break
+
+            # Execute tool calls (which may invoke sub-agents)
+            for tool_call in response.tool_calls:
+                result = await tools.execute_with_events(tool_call, ctx)
+
+                # Check for handoff
+                if isinstance(result, dict) and result.get("handoff"):
+                    # Sub-agent took over - we're done
+                    return RunResult(
+                        final_output=result.get("final_output", {}),
+                        final_messages=messages,
+                    )
+
+                # Add result to conversation
+                messages.append({
+                    "role": "tool",
+                    "tool_call_id": tool_call.id,
+                    "content": str(result.get("response", result)),
+                })
+
+        return RunResult(
+            final_output={"response": response.content},
+            final_messages=messages,
+        )
+```
+
+### Direct Invocation
+
+You can also invoke agents directly without the tool pattern:
+
+```python
+from agent_runtime_core.multi_agent import invoke_agent
+
+# Invoke a sub-agent directly
+result = await invoke_agent(
+    agent_tool=billing_tool,
+    message="Customer wants a refund for order #123",
+    parent_ctx=ctx,
+    conversation_history=messages,
+    additional_context="Customer has been waiting 2 weeks",
+)
+
+if result.handoff:
+    # Sub-agent took over
+    return RunResult(final_output=result.run_result.final_output)
+else:
+    # Use the response
+    print(result.response)
+```
+
+### Events
+
+Multi-agent invocations emit events for observability:
+
+- `sub_agent.start` - Sub-agent invocation started
+- `sub_agent.end` - Sub-agent invocation completed
+- `tool.call` with `is_agent_tool: true` - Agent-tool was called
+- `tool.result` with `is_agent_tool: true` - Agent-tool returned
+
+### AgentTool Options
+
+```python
+AgentTool(
+    agent=my_agent,                          # Required: The agent to wrap
+    name="specialist",                       # Required: Tool name
+    description="When to use this agent",    # Required: Shown to parent LLM
+    invocation_mode=InvocationMode.DELEGATE, # DELEGATE or HANDOFF
+    context_mode=ContextMode.FULL,           # FULL, SUMMARY, or MESSAGE_ONLY
+    max_turns=10,                            # Optional: Limit sub-agent turns
+    input_schema={...},                      # Optional: Custom input schema
+    metadata={"category": "billing"},        # Optional: Additional metadata
+)
+```
+
 ## API Reference
 
 ### Configuration

agent_runtime_core-0.7.1.dist-info/RECORD

@@ -0,0 +1,57 @@
+agent_runtime_core/__init__.py,sha256=fNQv_lSufnwrfGYKj6HduUOHzPtAZXqh5dUFShR9kGQ,7117
+agent_runtime_core/agentic_loop.py,sha256=DJ3RXaQLFlHMf-icQjpTJkAvdfjkPBSGN1S_iy3mf64,9635
+agent_runtime_core/config.py,sha256=WVfcIluFvf2zC_NKk2WuJhhPIGQNcuxmZV9TCg4t13o,7297
+agent_runtime_core/config_schema.py,sha256=1t2ZF5Rk2oRbeYpRATMdFgbvgTPtedIQO6xej4cELh0,10576
+agent_runtime_core/contexts.py,sha256=41UVkSqRJ3E9yIxfCQ-BQ7-wetUfSnDNGdr5-dQOWiY,11349
+agent_runtime_core/interfaces.py,sha256=QvRFPRc2Fwqv_sv-3nExCoaiqwBf_HsQo9yzCYE_Hm0,15498
+agent_runtime_core/json_runtime.py,sha256=b1BnGAQMORB4YULsKcCR0hEaCvln3Bz2dP228yq5BIQ,17358
+agent_runtime_core/multi_agent.py,sha256=UleIFocGW0GZFeoa_bPfYGLZZH-NYiEsiG2BBTGdKyA,18409
+agent_runtime_core/registry.py,sha256=QmazCAcHTsPt236Z_xEBJjdppm6jUuufE-gfvcGMUCk,3959
+agent_runtime_core/runner.py,sha256=ydzyGJHCyz1wjs-sN5dx4RlJsYK0U-Or12BL_Fg8-aQ,19595
+agent_runtime_core/steps.py,sha256=XpVFK7P-ZOpr7NwaP7XFygduIpjrKld-OIig7dHNMKE,11994
+agent_runtime_core/testing.py,sha256=ordECGprBappLBMWxlETvuf2AoIPNomJFeSedXaY30E,11131
+agent_runtime_core/tool_calling_agent.py,sha256=kyPTwHlYGaqUo0HJ7ycYCCQMFHD_AmPZMsyjxaKpJVc,5967
+agent_runtime_core/tools.py,sha256=SSbiViOJe7raSijwV_TSHI60F5ReHy43Vd_QrAkKgAk,5620
+agent_runtime_core/events/__init__.py,sha256=Gg7cMQHWfLTQ4Xik09KSg7cWbQDmW_MuF5_jl-yZkHU,1575
+agent_runtime_core/events/base.py,sha256=NfHYyoczxr40Er5emROi_aY_07m5hDrKsn31pdWY2DY,1950
+agent_runtime_core/events/memory.py,sha256=9z4tY8XB8xDg3ybHsIwilOcRo7HY-vB-8vxiz6O54BE,2491
+agent_runtime_core/events/redis.py,sha256=7PsUO2-iqrdGCJZUOq1IdzwDdNhqT5mwEnH5xy2Fklo,5874
+agent_runtime_core/events/sqlite.py,sha256=ZpGgeuQujYT8pkDsiXDoFXTcBf2KqzoWX4D4J9xkmeE,5097
+agent_runtime_core/llm/__init__.py,sha256=7-tA1FmPkhY1l-lHhzd84MQf2bjs26bcgb8oAlglc58,4605
+agent_runtime_core/llm/anthropic.py,sha256=AX2QJoQf-4uLDCxWFs71XfD11IMN6iI3gMPA25F3KrM,12239
+agent_runtime_core/llm/litellm_client.py,sha256=c-O-lE08cT3ne0xSOvSDezPL6hCiA69p3HnB451Ipe4,5193
+agent_runtime_core/llm/models_config.py,sha256=i275wtsWeR-LHdFrObPI19PtCIGvMDKTEKpue5TuYIk,5342
+agent_runtime_core/llm/openai.py,sha256=qBZkkndDgYQ6LG-9bHS2za5KJTGSgL-c_7h0bD3_5lg,6862
+agent_runtime_core/memory/__init__.py,sha256=7dgoXMr3IIjKsKKbxVgQBrrhZHqmJRIx64mcbF8jgUM,2178
+agent_runtime_core/memory/manager.py,sha256=ba8ZKb1aF9Pc-zZB4O_22b6zb6ELpvo_LhpSs959L5U,18474
+agent_runtime_core/memory/mixin.py,sha256=Afq7rhW1SmZgii6b3gUbM3peDzMwfMxQ0DstHzGfuDM,9683
+agent_runtime_core/persistence/__init__.py,sha256=HdkGW5hnLjBRE0QcUWVjL2xsIkMyKPpqJKpamPbFh0s,2822
+agent_runtime_core/persistence/base.py,sha256=k0wuzTCffPJ609dj9hIhnaqnNI1Qr3pCzJ-6E1YkSRU,21616
+agent_runtime_core/persistence/file.py,sha256=uZxl3W405jeX1H6f0Xj_pZOQFTpZOYbpIdJ98rZabBI,28712
+agent_runtime_core/persistence/manager.py,sha256=UL_eFsFM28nXM6O9PTHdzKX9Qxh9v2gBGd1m9Bs0vog,14309
+agent_runtime_core/queue/__init__.py,sha256=m8gapXACPGApLj0RIDpVe5cQYuvKq1QsY2_mXzZcULQ,1527
+agent_runtime_core/queue/base.py,sha256=QW1eWbwBX_tmVD8yJobFJtlxLd_RtUWHTuXGessuxy8,3959
+agent_runtime_core/queue/memory.py,sha256=G65NJ2QU8sB2WQ7myHXc8LzSFowEzBXtCt78WmhvxO8,5416
+agent_runtime_core/queue/redis.py,sha256=x9BEoeh6cVcWdaziFSQZHUvq_bHN1WYHWw17HIEWi5o,15622
+agent_runtime_core/queue/sqlite.py,sha256=3YwkU0QOcmAxYBpbfEB9xk8f-e2C3QcHK_RnPZvdick,14338
+agent_runtime_core/rag/__init__.py,sha256=ilsbzkcycLlhLa0BCCpdMb0EGnLaC-l52EH3xIyN6vw,1845
+agent_runtime_core/rag/chunking.py,sha256=wlFa_K4G1Mbkyy-g-JR67e4Xwb3-ysCmf8s1ar7s5Ls,6364
+agent_runtime_core/rag/indexer.py,sha256=BWq_BysZD1rMkAD_30mLe6qk6cDkut05DpfmrWMSLQc,8003
+agent_runtime_core/rag/retriever.py,sha256=-svCtkTL5n65KALssWM1MwxsTa4wIiUQKRf3j9GPrTM,8304
+agent_runtime_core/state/__init__.py,sha256=RK16Sj1QPW0SNxtmESlLRMpFBY_hZbMGGNnvcLbdcWw,1564
+agent_runtime_core/state/base.py,sha256=NqE3B0ySa-U2jkelgmkBbkmkaIQxfu4pDryoxkZTMrc,1593
+agent_runtime_core/state/memory.py,sha256=yEGwoR25zWcoxL79_gEu38P_dHvjJOTGij2wxqZ7X9A,1566
+agent_runtime_core/state/redis.py,sha256=VXY6ULEphehHVq4zSw5Y4AMCibm9Ghvzk7PqCrgStDg,3430
+agent_runtime_core/state/sqlite.py,sha256=HKZwDiC_7F1W8Z_Pz8roEs91XhQ9rUHfGpuQ7WWt_NQ,4873
+agent_runtime_core/tracing/__init__.py,sha256=u1QicGc39e30gWyQD4cQWxGGjITnkwoOPUhNrG6aNyI,1266
+agent_runtime_core/tracing/langfuse.py,sha256=Rj2sUlatk5sFro0y68tw5X6fQcSwWxcBOSOjB0F7JTU,3660
+agent_runtime_core/tracing/noop.py,sha256=SpsbpsUcNG6C3xZG3uyiNPUHY8etloISx3w56Q8D3KE,751
+agent_runtime_core/vectorstore/__init__.py,sha256=HO6B2TsHTPMkHvRf-774IgVtVcrOf_5P-yUPRpYIUj4,5688
+agent_runtime_core/vectorstore/base.py,sha256=y1ZZCbAMkFkbHwOqzaK0JUBAVjbnNwwdSnrxokzzvjQ,3426
+agent_runtime_core/vectorstore/embeddings.py,sha256=WTTiId9Q6I7cxHuiInYHEV8EWS2HyRYRW1YDPALGUVY,7749
+agent_runtime_core/vectorstore/sqlite_vec.py,sha256=B4KPYdSkm-af-uqltqMga1uXslC19Uaeuy1sXfKOjyo,10552
+agent_runtime_core/vectorstore/vertex.py,sha256=a1Ps_gMYqTlWUkNALpgMVEX6r6Zw_8gN5pZ59-vH7Ww,9695
+agent_runtime_core-0.7.1.dist-info/METADATA,sha256=AXI1AH7ZFAVmiwpI7pCP3pq0fdJUzvzbES_G7QjpSLA,30560
+agent_runtime_core-0.7.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+agent_runtime_core-0.7.1.dist-info/licenses/LICENSE,sha256=fDlWep3_mUrj8KHV_jk275tHVEW7_9sJRhkNuGCZ_TA,1068
+agent_runtime_core-0.7.1.dist-info/RECORD,,

agent_runtime_core-0.6.0.dist-info/RECORD

@@ -1,38 +0,0 @@
-agent_runtime_core/__init__.py,sha256=qPJb-oJ424TMygK4OxUpLqoOu8e4I68MWok1ufxOAzQ,4139
-agent_runtime_core/config.py,sha256=e3_uB5brAuQcWU36sOhWF9R6RoJrngtCS-xEB3n2fas,4986
-agent_runtime_core/interfaces.py,sha256=T74pgS229tvarQD-_o25oflylUR7jq_jbgUjnvVs6IA,12191
-agent_runtime_core/registry.py,sha256=QmazCAcHTsPt236Z_xEBJjdppm6jUuufE-gfvcGMUCk,3959
-agent_runtime_core/runner.py,sha256=M3It72UhfmLt17jVnSvObiSfQ1_RN4JVUIJsjnRd2Ps,12771
-agent_runtime_core/steps.py,sha256=XpVFK7P-ZOpr7NwaP7XFygduIpjrKld-OIig7dHNMKE,11994
-agent_runtime_core/testing.py,sha256=ordECGprBappLBMWxlETvuf2AoIPNomJFeSedXaY30E,11131
-agent_runtime_core/tool_calling_agent.py,sha256=LY0lSI9GZbWoIKd-7NXFSvByAhvK6L625eOp01VbTrw,8525
-agent_runtime_core/events/__init__.py,sha256=Gg7cMQHWfLTQ4Xik09KSg7cWbQDmW_MuF5_jl-yZkHU,1575
-agent_runtime_core/events/base.py,sha256=NfHYyoczxr40Er5emROi_aY_07m5hDrKsn31pdWY2DY,1950
-agent_runtime_core/events/memory.py,sha256=9z4tY8XB8xDg3ybHsIwilOcRo7HY-vB-8vxiz6O54BE,2491
-agent_runtime_core/events/redis.py,sha256=7PsUO2-iqrdGCJZUOq1IdzwDdNhqT5mwEnH5xy2Fklo,5874
-agent_runtime_core/events/sqlite.py,sha256=ZpGgeuQujYT8pkDsiXDoFXTcBf2KqzoWX4D4J9xkmeE,5097
-agent_runtime_core/llm/__init__.py,sha256=LyFFDtk4HhvUXct0nTeKuYuWzVmVqLDSVRpnPArbGqY,2461
-agent_runtime_core/llm/anthropic.py,sha256=pt9QAjrv2dIPSAY3Pv6N_BzxL1tbhL-kPWsQ-DcHMLI,7516
-agent_runtime_core/llm/litellm_client.py,sha256=c-O-lE08cT3ne0xSOvSDezPL6hCiA69p3HnB451Ipe4,5193
-agent_runtime_core/llm/openai.py,sha256=qBZkkndDgYQ6LG-9bHS2za5KJTGSgL-c_7h0bD3_5lg,6862
-agent_runtime_core/persistence/__init__.py,sha256=l9_1Mzhy9_Y-IIKuBKTR3Z8r2TPyr0a6b1HEdyZf1_I,2772
-agent_runtime_core/persistence/base.py,sha256=k0wuzTCffPJ609dj9hIhnaqnNI1Qr3pCzJ-6E1YkSRU,21616
-agent_runtime_core/persistence/file.py,sha256=oDB4_ZQkwHTCT1uoqpw5jOleK69YXCQwlTPsW86Yb-I,17785
-agent_runtime_core/persistence/manager.py,sha256=UL_eFsFM28nXM6O9PTHdzKX9Qxh9v2gBGd1m9Bs0vog,14309
-agent_runtime_core/queue/__init__.py,sha256=m8gapXACPGApLj0RIDpVe5cQYuvKq1QsY2_mXzZcULQ,1527
-agent_runtime_core/queue/base.py,sha256=QW1eWbwBX_tmVD8yJobFJtlxLd_RtUWHTuXGessuxy8,3959
-agent_runtime_core/queue/memory.py,sha256=G65NJ2QU8sB2WQ7myHXc8LzSFowEzBXtCt78WmhvxO8,5416
-agent_runtime_core/queue/redis.py,sha256=x9BEoeh6cVcWdaziFSQZHUvq_bHN1WYHWw17HIEWi5o,15622
-agent_runtime_core/queue/sqlite.py,sha256=3YwkU0QOcmAxYBpbfEB9xk8f-e2C3QcHK_RnPZvdick,14338
-agent_runtime_core/state/__init__.py,sha256=RK16Sj1QPW0SNxtmESlLRMpFBY_hZbMGGNnvcLbdcWw,1564
-agent_runtime_core/state/base.py,sha256=NqE3B0ySa-U2jkelgmkBbkmkaIQxfu4pDryoxkZTMrc,1593
-agent_runtime_core/state/memory.py,sha256=yEGwoR25zWcoxL79_gEu38P_dHvjJOTGij2wxqZ7X9A,1566
-agent_runtime_core/state/redis.py,sha256=VXY6ULEphehHVq4zSw5Y4AMCibm9Ghvzk7PqCrgStDg,3430
-agent_runtime_core/state/sqlite.py,sha256=HKZwDiC_7F1W8Z_Pz8roEs91XhQ9rUHfGpuQ7WWt_NQ,4873
-agent_runtime_core/tracing/__init__.py,sha256=u1QicGc39e30gWyQD4cQWxGGjITnkwoOPUhNrG6aNyI,1266
-agent_runtime_core/tracing/langfuse.py,sha256=Rj2sUlatk5sFro0y68tw5X6fQcSwWxcBOSOjB0F7JTU,3660
-agent_runtime_core/tracing/noop.py,sha256=SpsbpsUcNG6C3xZG3uyiNPUHY8etloISx3w56Q8D3KE,751
-agent_runtime_core-0.6.0.dist-info/METADATA,sha256=Q9egtbhBSMcgmeA9TM4gy_8P5pUcN0WFMCNaAOii12w,23858
-agent_runtime_core-0.6.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-agent_runtime_core-0.6.0.dist-info/licenses/LICENSE,sha256=fDlWep3_mUrj8KHV_jk275tHVEW7_9sJRhkNuGCZ_TA,1068
-agent_runtime_core-0.6.0.dist-info/RECORD,,