agent-framework-lib 0.8.1__tar.gz → 0.8.1.post3__tar.gz

{agent_framework_lib-0.8.1/agent_framework_lib.egg-info → agent_framework_lib-0.8.1.post3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-framework-lib
-Version: 0.8.1
+Version: 0.8.1.post3
 Summary: A comprehensive Python framework for building and serving conversational AI agents with FastAPI
 Author-email: Sebastian Pavel <sebastian@cinco.ai>, Elliott Girard <elliott.girard@icloud.com>
 Maintainer-email: Sebastian Pavel <sebastian@cinco.ai>
@@ -149,6 +149,13 @@ Dynamic: license-file
 
 # Agent Framework Library
 
+[![PyPI version](https://badge.fury.io/py/agent-framework-lib.svg)](https://pypi.org/project/agent-framework-lib/)
+[![Tests](https://github.com/Cinco-AI/AgentFramework/workflows/Tests%20%26%20Coverage/badge.svg)](https://github.com/Cinco-AI/AgentFramework/actions)
+[![Coverage](https://codecov.io/gh/Cinco-AI/AgentFramework/branch/main/graph/badge.svg)](https://codecov.io/gh/Cinco-AI/AgentFramework)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Documentation](https://img.shields.io/badge/docs-mkdocs-blue.svg)](https://cinco-ai.github.io/AgentFramework/)
+
 A comprehensive Python framework for building and serving conversational AI agents with FastAPI. Create production-ready AI agents in minutes with automatic session management, streaming responses, file storage, and easy MCP integration.
 
 **Key Features:**

{agent_framework_lib-0.8.1/agent_framework/web/docs → agent_framework_lib-0.8.1.post3}/README.md

@@ -1,5 +1,12 @@
 # Agent Framework Library
 
+[![PyPI version](https://badge.fury.io/py/agent-framework-lib.svg)](https://pypi.org/project/agent-framework-lib/)
+[![Tests](https://github.com/Cinco-AI/AgentFramework/workflows/Tests%20%26%20Coverage/badge.svg)](https://github.com/Cinco-AI/AgentFramework/actions)
+[![Coverage](https://codecov.io/gh/Cinco-AI/AgentFramework/branch/main/graph/badge.svg)](https://codecov.io/gh/Cinco-AI/AgentFramework)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Documentation](https://img.shields.io/badge/docs-mkdocs-blue.svg)](https://cinco-ai.github.io/AgentFramework/)
+
 A comprehensive Python framework for building and serving conversational AI agents with FastAPI. Create production-ready AI agents in minutes with automatic session management, streaming responses, file storage, and easy MCP integration.
 
 **Key Features:**

{agent_framework_lib-0.8.1 → agent_framework_lib-0.8.1.post3/agent_framework/web/docs}/README.md

@@ -1,5 +1,12 @@
 # Agent Framework Library
 
+[![PyPI version](https://badge.fury.io/py/agent-framework-lib.svg)](https://pypi.org/project/agent-framework-lib/)
+[![Tests](https://github.com/Cinco-AI/AgentFramework/workflows/Tests%20%26%20Coverage/badge.svg)](https://github.com/Cinco-AI/AgentFramework/actions)
+[![Coverage](https://codecov.io/gh/Cinco-AI/AgentFramework/branch/main/graph/badge.svg)](https://codecov.io/gh/Cinco-AI/AgentFramework)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Documentation](https://img.shields.io/badge/docs-mkdocs-blue.svg)](https://cinco-ai.github.io/AgentFramework/)
+
 A comprehensive Python framework for building and serving conversational AI agents with FastAPI. Create production-ready AI agents in minutes with automatic session management, streaming responses, file storage, and easy MCP integration.
 
 **Key Features:**

{agent_framework_lib-0.8.1 → agent_framework_lib-0.8.1.post3}/agent_framework/web/helper_agent.py

@@ -91,6 +91,7 @@ class FrameworkHelperAgent(LlamaIndexAgent):
     _indexed_docs: list[str] = []
     _indexed_examples: list[str] = []
     _indexed_source: list[str] = []
+    _indexed_skills: list[str] = []  # SKILL.md files from builtin skills
     _graphiti_episode_count: int = 0  # Count from FalkorDB when reusing existing graph
 
     AGENT_ID = "framework_helper_v2"
@@ -212,6 +213,75 @@ class FrameworkHelperAgent(LlamaIndexAgent):
             logger.warning(f"[FrameworkHelperAgent] Failed to read tools guide: {e}")
             return ""
 
+    def _load_custom_skills_guide(self) -> str:
+        """
+        Load the CUSTOM_SKILLS_GUIDE.md documentation.
+
+        Returns:
+            Content of the custom skills guide, or empty string if not available.
+        """
+        docs_path = self._get_docs_path()
+        guide_path = docs_path / "CUSTOM_SKILLS_GUIDE.md"
+
+        if not guide_path.exists():
+            logger.debug(f"[FrameworkHelperAgent] Custom skills guide not found: {guide_path}")
+            return ""
+
+        try:
+            content = guide_path.read_text(encoding="utf-8", errors="ignore")
+            # Truncate if too long (keep first ~15000 chars to stay within context limits)
+            if len(content) > 15000:
+                content = content[:15000] + "\n\n... (truncated for brevity)"
+            return content
+        except Exception as e:
+            logger.warning(f"[FrameworkHelperAgent] Failed to read custom skills guide: {e}")
+            return ""
+
+    def _load_skill_examples(self) -> str:
+        """
+        Load representative SKILL.md examples from builtin skills.
+
+        Loads 3 representative skills to show the SKILL.md format:
+        - chart (Skill_Script with visualization)
+        - form (Skill_Markdown with UI)
+        - powerpoint (Skill_Script with document generation)
+
+        Returns:
+            Formatted markdown string with skill definition examples.
+        """
+        source_path = self._get_source_path()
+        skills_path = source_path / "skills" / "builtin" / "skills"
+
+        if not skills_path.exists():
+            logger.debug(f"[FrameworkHelperAgent] Skills path not found: {skills_path}")
+            return "# No skill examples available"
+
+        # Representative skills showing different types
+        example_skills = [
+            ("chart", "Skill_Script for visualization (Chart.js)"),
+            ("form", "Skill_Markdown for UI (interactive forms)"),
+            ("powerpoint", "Skill_Script for document generation"),
+        ]
+
+        examples: list[str] = []
+
+        for skill_name, description in example_skills:
+            skill_md = skills_path / skill_name / "SKILL.md"
+            if skill_md.exists():
+                try:
+                    content = skill_md.read_text(encoding="utf-8", errors="ignore")
+                    # Truncate very long skills (keep first 3000 chars)
+                    if len(content) > 3000:
+                        content = content[:3000] + "\n\n... (truncated for brevity)"
+                    examples.append(f"### {skill_name} — {description}\n```markdown\n{content}\n```")
+                except Exception as e:
+                    logger.warning(f"[FrameworkHelperAgent] Failed to read skill {skill_name}: {e}")
+
+        if not examples:
+            return "# No skill examples available"
+
+        return "\n\n".join(examples)
+
     def _get_base_prompt(self) -> str:
         """
         Return the base system prompt for framework assistance.
@@ -241,19 +311,75 @@ def get_agent_prompt(self) -> str:
     return \"\"\"You are a helpful assistant that...\"\"\"
 ```
 
-### 2. `get_agent_tools()` - Add capabilities
+### 2. Skills System - Add Capabilities (RECOMMENDED)
+
+**AgentFramework provides 21 builtin skills that agents can use on-demand:**
+
+#### How Skills Work
+- **Auto-loading**: Skills auto-load when user queries match trigger patterns (e.g., "create a chart" loads the `chart` skill)
+- **On-demand**: Only loaded when needed, reducing token usage by ~80%
+- **Two types**:
+  - **Skill_Markdown** (10 skills): Instructions-only, no executable code
+  - **Skill_Script** (11 skills): With executable Python scripts for file generation
+
+#### Skills by Category
+
+**Visualization (3 skills)**
+- `chart` — Chart.js charts (bar, line, pie, etc.) or PNG export
+- `mermaid` — Mermaid diagrams (flowcharts, sequence, UML, etc.)
+- `table` — Formatted tables or PNG export
+
+**Document (7 skills)**
+- `file` — File operations (create, read, list)
+- `unified_pdf` — PDF generation from HTML with embedded images
+- `file_access` — Download URLs for stored files
+- `excel` — Excel (.xlsx) generation with multi-sheet support
+- `drawio` — Draw.io diagrams (.drawio)
+- `powerpoint` — PowerPoint presentations (.pptx)
+- `word` — Word documents (.docx)
+
+**Data (2 skills)**
+- `csv` — CSV manipulation (create, read, transform)
+- `data_format` — JSON ↔ YAML conversion, schema validation
+
+**Code (1 skill)**
+- `code_format` — Code formatting (Python, JS, JSON, YAML)
+
+**Web (1 skill)**
+- `web_search` — DuckDuckGo web search and news
+
+**Multimodal (2 skills)**
+- `multimodal` — Multimodal processing instructions (images, audio)
+- `image_gen` — AI image generation (DALL-E 3 and DALL-E 2)
+
+**UI (5 skills)**
+- `form` — Interactive forms (JSON formDefinition)
+- `optionsblock` — Clickable option buttons
+- `image_display` — Display images in chat
+- `email_template` — Responsive HTML email templates
+- `skill_creator` — Guide for creating custom skills
+
+**Skills auto-load by default** — agents don't need to do anything special to use them!
+
+### 3. `get_agent_tools()` - Add Custom Tools (Optional)
+For capabilities beyond the 21 builtin skills, you can define custom tools:
 ```python
 def get_agent_tools(self) -> List[callable]:
-    def my_tool(param: str) -> str:
+    def my_custom_tool(param: str) -> str:
         \"\"\"Tool description for the LLM.\"\"\"
         return f"Result: {param}"
-    return [my_tool]
+    return [my_custom_tool]
 ```
 
-### 3. `initialize_agent()` - (Optional) Customize agent initialization
+**When to use custom tools vs skills:**
+- Use **builtin skills** for common tasks (charts, PDFs, Excel, search, etc.)
+- Use **custom tools** for domain-specific logic unique to your agent
+- Both can coexist: skills + custom tools work together seamlessly
+
+### 4. `initialize_agent()` - (Optional) Customize agent initialization
 The default implementation uses FunctionAgent. Override only if you need custom behavior.
 
-### 4. `get_memory_config()` - (Optional) Enable memory
+### 5. `get_memory_config()` - (Optional) Enable memory
 ```python
 def get_memory_config(self) -> Optional[MemoryConfig]:
     return MemoryConfig.memori_simple(database_url="sqlite:///memory.db")
@@ -283,6 +409,8 @@ Be helpful, provide working code examples, and explain framework concepts clearl
         - LlamaIndexAgent source code (for accurate reference)
         - Example agent implementations from the docs
         - Tools and MCP integration guide
+        - Custom skills guide (how to create new skills)
+        - Skill definition examples (SKILL.md format reference)
 
         This ensures the agent has accurate, up-to-date information about
         the framework regardless of whether it's running from source or PyPI.
@@ -291,6 +419,8 @@ Be helpful, provide working code examples, and explain framework concepts clearl
         source_code = self._load_llamaindex_agent_source()
         examples = self._load_doc_examples()
         tools_guide = self._load_tools_and_mcp_guide()
+        skills_guide = self._load_custom_skills_guide()
+        skill_examples = self._load_skill_examples()
 
         prompt = f"""{base_prompt}
 
@@ -315,6 +445,24 @@ These are complete, runnable examples showing different agent patterns:
 Complete reference for creating tools and integrating MCP servers:
 
 {tools_guide}
+"""
+
+        if skills_guide:
+            prompt += f"""
+
+## Custom Skills Creation Guide
+Complete guide for creating custom skills (both Skill_Markdown and Skill_Script):
+
+{skills_guide}
+"""
+
+        if skill_examples:
+            prompt += f"""
+
+## Builtin Skill Examples (SKILL.md Format Reference)
+These examples show the SKILL.md format used by builtin skills:
+
+{skill_examples}
 """
 
         return prompt
@@ -357,7 +505,7 @@ Complete reference for creating tools and integrating MCP servers:
             are available for searching.
 
             Args:
-                file_type: Filter by type - "docs", "examples", "source", or "all"
+                file_type: Filter by type - "docs", "examples", "skills", "source", or "all"
 
             Returns:
                 List of indexed files by category
@@ -366,7 +514,7 @@ Complete reference for creating tools and integrating MCP servers:
             cls = FrameworkHelperAgent
 
             # Check if we're using a reused FalkorDB graph (lists are empty but episodes exist)
-            has_local_lists = any([cls._indexed_docs, cls._indexed_examples, cls._indexed_source])
+            has_local_lists = any([cls._indexed_docs, cls._indexed_examples, cls._indexed_skills, cls._indexed_source])
 
             if not has_local_lists:
                 # Try to get episode names from FalkorDB
@@ -385,6 +533,7 @@ Complete reference for creating tools and integrating MCP servers:
                         "**Indexed content includes:**\n"
                         "- Documentation files (docs/*.md)\n"
                         "- Example agents (examples/*.py)\n"
+                        "- Skill definitions (21 builtin skills)\n"
                         "- Core source files (agent_framework/core/, implementations/, etc.)\n\n"
                         "Use `search_knowledge(query)` to search across all indexed content."
                     )
@@ -408,6 +557,13 @@ Complete reference for creating tools and integrating MCP servers:
                     for f in examples:
                         result.append(f"  - {f}")
 
+            if file_type in ("all", "skills"):
+                skills = cls._indexed_skills or []
+                if skills:
+                    result.append(f"\n**Skills ({len(skills)} builtin):**")
+                    for f in skills:
+                        result.append(f"  - {f}")
+
             if file_type in ("all", "source"):
                 source = cls._indexed_source or []
                 if source:
@@ -478,6 +634,150 @@ Complete reference for creating tools and integrating MCP servers:
                 logger.error(f"Web search error: {e}")
                 return f"Search failed: {e}"
 
+        async def search_skills(query: str) -> str:
+            """
+            Search builtin skills by semantic query or trigger patterns.
+
+            Use this to find which skills are available for specific tasks.
+            Examples: "chart creation", "PDF generation", "image processing"
+
+            Args:
+                query: What capability you're looking for
+
+            Returns:
+                List of relevant skills with their descriptions and trigger patterns
+            """
+            try:
+                # Search Graphiti for skill episodes
+                if self._shared_graphiti_client is not None:
+                    results = await self._search_graphiti(f"skill:{query}", num_results=5)
+                    if results and "No relevant information found" not in results:
+                        return f"Skills matching '{query}':\n\n{results}"
+
+                # Fallback: return list of all skills by category
+                cls = FrameworkHelperAgent
+                if cls._indexed_skills:
+                    skills_list = ", ".join(sorted(cls._indexed_skills))
+                    return (
+                        f"Semantic search not available. All 21 builtin skills: {skills_list}\n\n"
+                        f"Use `get_skill_details(skill_name)` to see full documentation for a specific skill.\n"
+                        f"Or use `search_knowledge(\"{query}\")` for general search across all content."
+                    )
+
+                return (
+                    "Skills are indexed in the knowledge base. "
+                    f"Use `search_knowledge(\"{query}\")` to find relevant skills."
+                )
+
+            except Exception as e:
+                logger.warning(f"Skill search failed: {e}")
+                return f"Skill search failed: {e}. Try `list_indexed_files('skills')` to see all skills."
+
+        async def get_skill_details(skill_name: str) -> str:
+            """
+            Get the complete SKILL.md content for a specific builtin skill.
+
+            Use this to see the full documentation, trigger patterns, usage examples,
+            and script entrypoints for a skill.
+
+            Args:
+                skill_name: Name of the skill (e.g., "chart", "pdf", "excel", "powerpoint")
+
+            Returns:
+                Full SKILL.md content with all usage instructions
+            """
+            source_path = self._get_source_path()
+            skill_md = source_path / "skills" / "builtin" / "skills" / skill_name / "SKILL.md"
+
+            if not skill_md.exists():
+                cls = FrameworkHelperAgent
+                available_skills = ", ".join(sorted(cls._indexed_skills)) if cls._indexed_skills else "unknown"
+                return (
+                    f"Skill '{skill_name}' not found.\n\n"
+                    f"Available skills: {available_skills}\n\n"
+                    "Use `list_indexed_files('skills')` to see all indexed skills."
+                )
+
+            try:
+                content = skill_md.read_text(encoding="utf-8", errors="ignore")
+                return f"# {skill_name} Skill Documentation\n\n{content}"
+            except Exception as e:
+                logger.warning(f"Failed to read skill {skill_name}: {e}")
+                return f"Failed to read skill '{skill_name}': {e}"
+
+        async def recommend_skills_for_task(task_description: str) -> str:
+            """
+            Recommend the best builtin skills for a given agent task.
+
+            Use this when creating an agent to determine which skills it should have access to.
+
+            Args:
+                task_description: Description of what the agent needs to do
+                                (e.g., "analyze sales data and create reports")
+
+            Returns:
+                List of recommended skills with justifications
+            """
+            # Keywords mapping to skills
+            skill_keywords = {
+                "chart": ["chart", "graph", "plot", "visualization", "bar", "line", "pie"],
+                "mermaid": ["diagram", "flowchart", "sequence", "uml", "architecture", "workflow"],
+                "table": ["table", "tabular", "grid", "data table"],
+                "file": ["file", "read file", "write file", "create file"],
+                "unified_pdf": ["pdf", "report", "document pdf", "generate pdf"],
+                "file_access": ["download", "file access", "get file"],
+                "excel": ["excel", "spreadsheet", "xlsx", "workbook"],
+                "drawio": ["drawio", "architecture diagram", "technical diagram"],
+                "powerpoint": ["powerpoint", "presentation", "slides", "pptx"],
+                "word": ["word", "document", "docx", "text document"],
+                "web_search": ["search", "web search", "internet", "lookup", "news"],
+                "multimodal": ["image", "audio", "multimodal", "vision", "picture"],
+                "image_gen": ["generate image", "create image", "dall-e", "ai image"],
+                "form": ["form", "input", "interactive form"],
+                "optionsblock": ["options", "buttons", "choices", "select"],
+                "image_display": ["show image", "display image"],
+                "email_template": ["email", "email template", "html email"],
+                "skill_creator": ["create skill", "custom skill", "new skill"],
+                "csv": ["csv", "comma separated", "data file"],
+                "data_format": ["json", "yaml", "convert", "schema", "validation"],
+                "code_format": ["format code", "code formatting", "prettier", "black"],
+            }
+
+            # Find matching skills
+            task_lower = task_description.lower()
+            recommendations = []
+
+            for skill_name, keywords in skill_keywords.items():
+                if any(keyword in task_lower for keyword in keywords):
+                    recommendations.append(skill_name)
+
+            if not recommendations:
+                return (
+                    f"No specific skills identified for: '{task_description}'\n\n"
+                    "**General recommendation:** Most agents work well with auto-loaded skills.\n"
+                    "Skills will automatically load when users mention trigger words (e.g., 'chart', 'pdf', 'excel').\n\n"
+                    "Use `search_skills(query)` or `list_indexed_files('skills')` to explore all 21 builtin skills."
+                )
+
+            # Build detailed recommendations
+            result = [f"Recommended skills for '{task_description}':\n"]
+
+            for skill in recommendations[:5]:  # Limit to top 5
+                # Get basic info about the skill
+                skill_info = await get_skill_details(skill)
+                # Extract just the first few lines for summary
+                lines = skill_info.split("\n")[:10]
+                summary = "\n".join(lines)
+                result.append(f"\n**{skill}**")
+                result.append(f"{summary}\n")
+
+            result.append(
+                "\n**Note:** Skills auto-load when needed. You don't need to explicitly configure them "
+                "unless you want to restrict which skills are available."
+            )
+
+            return "\n".join(result)
+
         # Create FunctionTool instances with async_fn (same pattern as memory tools)
         return [
             FunctionTool.from_defaults(
@@ -493,7 +793,7 @@ Complete reference for creating tools and integrating MCP servers:
                 name="list_indexed_files",
                 description=(
                     "List all files indexed in the knowledge base. "
-                    "Filter by type: 'docs', 'examples', 'source', or 'all'."
+                    "Filter by type: 'docs', 'examples', 'skills', 'source', or 'all'."
                 )
             ),
             FunctionTool.from_defaults(
@@ -512,6 +812,30 @@ Complete reference for creating tools and integrating MCP servers:
                     "Use for Python libraries, best practices, or topics not in framework docs."
                 )
             ),
+            FunctionTool.from_defaults(
+                async_fn=search_skills,
+                name="search_skills",
+                description=(
+                    "Search builtin skills by semantic query or trigger patterns. "
+                    "Use to find which skills are available for specific tasks."
+                )
+            ),
+            FunctionTool.from_defaults(
+                async_fn=get_skill_details,
+                name="get_skill_details",
+                description=(
+                    "Get complete SKILL.md documentation for a specific builtin skill. "
+                    "Shows trigger patterns, usage examples, and script entrypoints."
+                )
+            ),
+            FunctionTool.from_defaults(
+                async_fn=recommend_skills_for_task,
+                name="recommend_skills_for_task",
+                description=(
+                    "Recommend the best builtin skills for a given agent task. "
+                    "Use when creating an agent to determine which skills it should have."
+                )
+            ),
         ]
 
     async def initialize_agent(
@@ -992,12 +1316,16 @@ Complete reference for creating tools and integrating MCP servers:
         example_errors = await cls._index_examples_async()
         indexing_errors.extend(example_errors)
 
+        # Index skill definitions (SKILL.md files)
+        skill_errors = await cls._index_skill_definitions_async()
+        indexing_errors.extend(skill_errors)
+
         # Index source files with relationship extraction
         source_errors = await cls._index_source_files_async()
         indexing_errors.extend(source_errors)
 
         cls._shared_knowledge_indexed = True
-        total = len(cls._indexed_docs) + len(cls._indexed_examples) + len(cls._indexed_source)
+        total = len(cls._indexed_docs) + len(cls._indexed_examples) + len(cls._indexed_skills) + len(cls._indexed_source)
         logger.info(f"[FrameworkHelperAgent] Indexed {total} files successfully")
 
         if indexing_errors:
@@ -1089,6 +1417,58 @@ Complete reference for creating tools and integrating MCP servers:
         logger.info(f"[FrameworkHelperAgent] Indexed {len(cls._indexed_examples)} example files")
         return errors
 
+    @classmethod
+    async def _index_skill_definitions_async(cls) -> list[str]:
+        """
+        Index SKILL.md files from builtin skills directory into Graphiti.
+
+        This indexes all 21 builtin skill definitions with their:
+        - Trigger patterns for discovery
+        - Capabilities and usage instructions
+        - Entrypoint commands (for Skill_Script types)
+        - Examples and metadata
+
+        Returns:
+            List of error messages for files that failed to index
+        """
+        errors: list[str] = []
+        source_path = cls._get_source_path()
+        skills_path = source_path / "skills" / "builtin" / "skills"
+
+        if not skills_path.exists():
+            logger.warning(f"[FrameworkHelperAgent] Skills path not found: {skills_path}")
+            return errors
+
+        # Find all SKILL.md files in subdirectories
+        skill_md_files = list(skills_path.glob("*/SKILL.md"))
+
+        for skill_md in skill_md_files:
+            try:
+                content = skill_md.read_text(encoding="utf-8", errors="ignore")
+                skill_name = skill_md.parent.name
+                cls._indexed_skills.append(skill_name)
+
+                # Index into Graphiti if client is available
+                if cls._shared_graphiti_client is not None:
+                    await cls._add_episode_to_graphiti(
+                        name=f"skill:{skill_name}",
+                        content=content,
+                        source_description=f"Skill definition: {skill_name}",
+                        chunk_type="skill_definition",
+                    )
+                    # Rate limit protection: wait between indexing operations
+                    await asyncio.sleep(2.0)
+
+                logger.debug(f"[FrameworkHelperAgent] Indexed skill: {skill_name}")
+
+            except Exception as e:
+                error_msg = f"Error indexing skill {skill_md.parent.name}: {e}"
+                logger.error(f"[FrameworkHelperAgent] {error_msg}")
+                errors.append(error_msg)
+
+        logger.info(f"[FrameworkHelperAgent] Indexed {len(cls._indexed_skills)} skill definitions")
+        return errors
+
     @classmethod
     async def _index_source_files_async(cls) -> list[str]:
         """
@@ -1447,7 +1827,7 @@ Complete reference for creating tools and integrating MCP servers:
     @classmethod
     def get_indexed_files_count(cls) -> int:
         """Get total count of indexed files."""
-        local_count = len(cls._indexed_docs) + len(cls._indexed_examples) + len(cls._indexed_source)
+        local_count = len(cls._indexed_docs) + len(cls._indexed_examples) + len(cls._indexed_skills) + len(cls._indexed_source)
         # If we have a count from FalkorDB (reused graph), use that if local is empty
         if local_count == 0 and cls._graphiti_episode_count > 0:
             return cls._graphiti_episode_count

{agent_framework_lib-0.8.1 → agent_framework_lib-0.8.1.post3}/agent_framework/web/server.py

@@ -703,6 +703,7 @@ async def lifespan(app: FastAPI):
                 session_storage=session_storage,
                 agent_class=agent_class,
                 agent_manager=agent_manager,
+                app=app,
             )
             app.include_router(workspace_router)
             app.state.workspace_config = ws_config

{agent_framework_lib-0.8.1 → agent_framework_lib-0.8.1.post3}/agent_framework/workspace/client.py

@@ -382,6 +382,18 @@ class WorkspaceClient:
         """Remove a member from a workspace."""
         await self._request("DELETE", f"/workspaces/{workspace_id}/members/{member_id}")
 
+    # ------------------------------------------------------------------
+    # Typing indicator
+    # ------------------------------------------------------------------
+
+    async def start_writing(self, workspace_id: str) -> None:
+        """Signal that the agent started composing a response."""
+        await self._request("POST", f"/workspaces/{workspace_id}/writing/start")
+
+    async def stop_writing(self, workspace_id: str) -> None:
+        """Signal that the agent finished composing a response."""
+        await self._request("POST", f"/workspaces/{workspace_id}/writing/stop")
+
     # ------------------------------------------------------------------
     # Lifecycle
     # ------------------------------------------------------------------