afm-core 0.1.0.dev1__py3-none-any.whl

afm/exceptions.py

@@ -0,0 +1,109 @@
+# Copyright (c) 2025
+# Licensed under the Apache License, Version 2.0
+
+
+class AFMError(Exception):
+    pass
+
+
+class AFMParseError(AFMError):
+    def __init__(self, message: str, line: int | None = None):
+        self.line = line
+        if line is not None:
+            message = f"Line {line}: {message}"
+        super().__init__(message)
+
+
+class AFMValidationError(AFMError):
+    def __init__(self, message: str, field: str | None = None):
+        self.field = field
+        if field is not None:
+            message = f"Field '{field}': {message}"
+        super().__init__(message)
+
+
+class VariableResolutionError(AFMError):
+    def __init__(self, variable: str, reason: str):
+        self.variable = variable
+        self.reason = reason
+        super().__init__(f"Cannot resolve variable '${{{variable}}}': {reason}")
+
+
+class TemplateError(AFMError):
+    def __init__(self, message: str, template: str | None = None):
+        self.template = template
+        super().__init__(message)
+
+
+class TemplateCompilationError(TemplateError):
+    pass
+
+
+class TemplateEvaluationError(TemplateError):
+    pass
+
+
+class JSONAccessError(AFMError):
+    def __init__(self, message: str, path: str | None = None):
+        self.path = path
+        super().__init__(message)
+
+
+class AgentError(AFMError):
+    pass
+
+
+class ProviderError(AgentError):
+    def __init__(self, message: str, provider: str | None = None):
+        self.provider = provider
+        if provider is not None:
+            message = f"Provider '{provider}': {message}"
+        super().__init__(message)
+
+
+class InputValidationError(AFMValidationError):
+    def __init__(self, message: str, schema_path: str | None = None):
+        self.schema_path = schema_path
+        super().__init__(message, field="input")
+
+
+class OutputValidationError(AFMValidationError):
+    def __init__(self, message: str, schema_path: str | None = None):
+        self.schema_path = schema_path
+        super().__init__(message, field="output")
+
+
+class InterfaceNotFoundError(AFMError):
+    def __init__(self, interface_type: str, available: list[str]) -> None:
+        self.interface_type = interface_type
+        self.available = available
+        super().__init__(
+            f"Interface type '{interface_type}' not found. "
+            f"Available: {available if available else ['consolechat (default)']}"
+        )
+
+
+class MCPError(AFMError):
+    def __init__(self, message: str, server_name: str | None = None):
+        self.server_name = server_name
+        if server_name is not None:
+            message = f"MCP server '{server_name}': {message}"
+        super().__init__(message)
+
+
+class MCPConnectionError(MCPError):
+    pass
+
+
+class MCPToolError(MCPError):
+    def __init__(
+        self, message: str, server_name: str | None = None, tool_name: str | None = None
+    ):
+        self.tool_name = tool_name
+        if tool_name is not None:
+            message = f"Tool '{tool_name}': {message}"
+        super().__init__(message, server_name)
+
+
+class MCPAuthenticationError(MCPError):
+    pass

afm/interfaces/__init__.py

@@ -0,0 +1,2 @@
+# Copyright (c) 2025
+# Licensed under the Apache License, Version 2.0

afm/interfaces/base.py

@@ -0,0 +1,57 @@
+# Copyright (c) 2025
+# Licensed under the Apache License, Version 2.0
+
+from __future__ import annotations
+
+from ..exceptions import InterfaceNotFoundError
+from ..models import (
+    AFMRecord,
+    ConsoleChatInterface,
+    Interface,
+    InterfaceType,
+    WebChatInterface,
+    WebhookInterface,
+)
+
+
+def get_interfaces(afm: AFMRecord) -> list[Interface]:
+    if afm.metadata.interfaces:
+        return list(afm.metadata.interfaces)
+    # Default to consolechat if no interfaces specified
+    return [ConsoleChatInterface()]
+
+
+def get_interface_by_type(
+    afm: AFMRecord,
+    interface_type: InterfaceType,
+) -> Interface:
+    interfaces = get_interfaces(afm)
+
+    for interface in interfaces:
+        if interface.type == interface_type.value:
+            return interface
+
+    available = [iface.type for iface in interfaces]
+    raise InterfaceNotFoundError(interface_type.value, available)
+
+
+def get_webchat_interface(afm: AFMRecord) -> WebChatInterface:
+    interface = get_interface_by_type(afm, InterfaceType.WEB_CHAT)
+    assert isinstance(interface, WebChatInterface)
+    return interface
+
+
+def get_webhook_interface(afm: AFMRecord) -> WebhookInterface:
+    interface = get_interface_by_type(afm, InterfaceType.WEBHOOK)
+    assert isinstance(interface, WebhookInterface)
+    return interface
+
+
+def get_http_path(interface: WebChatInterface | WebhookInterface) -> str:
+    if interface.exposure and interface.exposure.http:
+        return interface.exposure.http.path
+
+    # Defaults per spec
+    if isinstance(interface, WebChatInterface):
+        return "/chat"
+    return "/webhook"

afm/interfaces/console_chat.py

@@ -0,0 +1,179 @@
+# Copyright (c) 2025
+# Licensed under the Apache License, Version 2.0
+
+from __future__ import annotations
+
+import logging
+import uuid
+from typing import TYPE_CHECKING
+
+from rich.markup import escape
+from textual import work
+from textual.app import App, ComposeResult
+from textual.containers import Vertical, VerticalScroll
+from textual.widgets import Footer, Header, Input, LoadingIndicator, Static
+
+if TYPE_CHECKING:
+    from ..runner import AgentRunner
+
+logger = logging.getLogger(__name__)
+
+
+class ChatApp(App):
+    CSS_PATH = "console_chat.tcss"
+    BINDINGS = [
+        ("ctrl+q", "quit", "Quit"),
+        ("ctrl+l", "clear_history", "Clear History"),
+        ("ctrl+h", "show_help", "Help"),
+    ]
+
+    def __init__(
+        self,
+        agent: AgentRunner,
+        session_id: str | None = None,
+    ):
+        super().__init__()
+        self.agent = agent
+        self.session_id = session_id or str(uuid.uuid4())
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield VerticalScroll(id="chat-log")
+        yield Input(placeholder="Type a message...", id="chat-input")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        logger.debug("ChatApp.on_mount called")
+        self.title = f"Chat with {self.agent.name}"
+        if self.agent.description:
+            self.sub_title = self.agent.description
+
+        # Show welcome message
+        welcome_msg = (
+            f"Welcome to chat with {self.agent.name}!\n"
+            "type 'exit', 'quit' or Ctrl+Q to end.\n"
+            "type 'help' or Ctrl+H for help.\n"
+            "type 'clear' or Ctrl+L to clear history."
+        )
+        self.query_one("#chat-log").mount(Static(welcome_msg, classes="system-message"))
+        self.query_one("#chat-input").focus()
+
+    async def on_input_submitted(self, event: Input.Submitted) -> None:
+        logger.debug(f"on_input_submitted triggered. Value: '{event.value}'")
+        try:
+            user_input = event.value.strip()
+            logger.debug(f"Input submitted: {user_input}")
+            if not user_input:
+                return
+
+            # Clear input
+            event.input.value = ""
+
+            # Handle local commands
+            command = user_input.lower()
+            if command in ("exit", "quit"):
+                self.exit()
+                return
+
+            if command == "help":
+                self.action_show_help()
+                return
+
+            if command == "clear":
+                self.action_clear_history()
+                return
+
+            # Display user message
+            chat_log = self.query_one("#chat-log")
+            msg_widget = Static(f"{escape(user_input)}", classes="message user-message")
+            await chat_log.mount(
+                Vertical(
+                    msg_widget, classes="message-container message-container--user"
+                )
+            )
+
+            # Send to agent
+            self._send_message(user_input)
+        except Exception:
+            logger.exception("Error in on_input_submitted")
+
+    @work(exclusive=True)
+    async def _send_message(self, user_input: str) -> None:
+        logger.debug(f"Sending message to agent: {user_input}")
+
+        try:
+            chat_log = self.query_one("#chat-log", VerticalScroll)
+
+            # Show thinking indicator
+            thinking = LoadingIndicator()
+            await chat_log.mount(thinking)
+            chat_log.scroll_end(animate=False)
+
+            response = await self.agent.arun(user_input, session_id=self.session_id)
+
+            # Handle non-string responses
+            if not isinstance(response, str):
+                import json
+
+                response = json.dumps(response, indent=2)
+
+            # Remove thinking and show response
+            await thinking.remove()
+            logger.debug(f"Mounting response: '{response}'")
+
+            msg_widget = Static(f"{escape(response)}", classes="message agent-message")
+            await chat_log.mount(
+                Vertical(
+                    msg_widget, classes="message-container message-container--agent"
+                )
+            )
+            chat_log.scroll_end(animate=True)
+
+        except Exception as e:
+            logger.exception("Error in _send_message")
+            # Try to report error to UI if possible
+            try:
+                chat_log = self.query_one("#chat-log", VerticalScroll)
+                # Ensure thinking is removed if it was added
+                try:
+                    await thinking.remove()
+                except UnboundLocalError:
+                    pass
+                except Exception:
+                    logger.debug("Failed to remove thinking indicator")
+                    pass
+
+                await chat_log.mount(
+                    Static(f"[Error: {str(e)}]", classes="error-message", markup=False)
+                )
+            except Exception as e2:
+                logger.exception(f"Could not report error to UI: {e2}")
+
+    def action_show_help(self) -> None:
+        help_msg = (
+            "Available commands:\n"
+            "  exit, quit, Ctrl+Q  - End the chat session\n"
+            "  help,     Ctrl+H    - Show this help message\n"
+            "  clear,    Ctrl+L    - Clear conversation history"
+        )
+        self.query_one("#chat-log").mount(Static(help_msg, classes="system-message"))
+        self.query_one("#chat-log").scroll_end()
+
+    def action_clear_history(self) -> None:
+        """Clear conversation history."""
+        self.agent.clear_history(self.session_id)
+        self.query_one("#chat-log").mount(
+            Static(
+                "[Conversation history cleared]", classes="system-message", markup=False
+            )
+        )
+        self.query_one("#chat-log").scroll_end()
+
+
+async def async_run_console_chat(
+    agent: AgentRunner,
+    *,
+    session_id: str | None = None,
+) -> None:
+    app = ChatApp(agent, session_id=session_id)
+    await app.run_async()

afm/interfaces/console_chat.tcss

@@ -0,0 +1,105 @@
+/* Main layout */
+Screen {
+    layout: vertical;
+    background: $surface;
+}
+
+/* Header area */
+Header {
+    dock: top;
+    height: 3;
+    content-align: center middle;
+    background: $primary-darken-2;
+    color: $text;
+    text-style: bold;
+}
+
+HeaderIcon {
+    display: none;
+}
+
+HeaderTitle {
+    content-align: center middle;
+    height: 100%;
+}
+
+/* Chat log area */
+#chat-log {
+    height: 1fr;
+    padding: 1 2;
+    overflow-y: auto;
+    scrollbar-size: 1 1;
+    background: $surface;
+}
+
+/* Input area */
+#chat-input {
+    dock: bottom;
+    height: 3;
+    margin: 1 0;
+    border: tall $primary-darken-2;
+    background: $surface-lighten-1;
+}
+
+/* Message Containers */
+.message-container {
+    width: 100%;
+    height: auto;
+    margin-bottom: 1;
+}
+
+.message-container--user {
+    align: right middle;
+}
+
+.message-container--agent {
+    align: left middle;
+}
+
+/* Message Bubbles */
+.message {
+    width: auto;
+    max-width: 80%;
+    height: auto;
+    padding: 0 1; 
+    background: $surface;
+    color: $text;
+}
+
+.user-message {
+    color: $text;
+    border: round $primary;
+}
+
+.agent-message {
+    color: $text;
+    border: round $success;
+}
+
+.system-message {
+    width: 100%;
+    content-align: center middle;
+    color: $text-muted;
+    text-style: italic;
+    background: transparent;
+    border: none;
+    margin: 1 0;
+}
+
+.error-message {
+    background: $error-darken-2;
+    color: $text;
+    border: heavy $error-lighten-1;
+}
+
+.thinking-message {
+    color: $warning;
+    text-style: italic;
+    padding-left: 1;
+}
+
+LoadingIndicator {
+    height: 1;
+    color: $accent;
+    background: transparent;
+}