aury-agent 0.0.4__py3-none-any.whl

aury/agents/cli/session.py

@@ -0,0 +1,337 @@
+"""
+会话管理命令
+============
+
+管理 Agent 会话。
+"""
+import asyncio
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from aury.agents.cli.config import load_config, DEFAULT_CONFIG_DIR
+
+session_app = typer.Typer(help="会话管理命令")
+console = Console()
+
+# 默认会话存储路径
+DEFAULT_SESSIONS_DIR = DEFAULT_CONFIG_DIR / "sessions"
+
+
+def _get_session_service(config: dict):
+    """获取会话服务实例。"""
+    from aury.agents.core.services import FileSessionService
+    
+    storage_path = config.get("session", {}).get(
+        "storage_path",
+        str(DEFAULT_SESSIONS_DIR)
+    )
+    
+    return FileSessionService(storage_path=storage_path)
+
+
+@session_app.command("list")
+def list_sessions(
+    config_file: Optional[Path] = typer.Option(
+        None,
+        "--config", "-c",
+        help="配置文件路径",
+    ),
+    limit: int = typer.Option(
+        20,
+        "--limit", "-n",
+        help="显示数量限制",
+    ),
+):
+    """列出所有会话。"""
+    config = load_config(config_file)
+    service = _get_session_service(config)
+    
+    # 获取会话列表
+    sessions = asyncio.run(service.list())
+    
+    if not sessions:
+        console.print("[dim]暂无会话[/dim]")
+        return
+    
+    table = Table(title=f"会话列表 (共 {len(sessions)} 个)")
+    table.add_column("会话 ID", style="cyan")
+    table.add_column("创建时间")
+    table.add_column("消息数")
+    table.add_column("状态")
+    
+    for session_id in sessions[:limit]:
+        try:
+            session = asyncio.run(service.load(session_id))
+            created = session.metadata.get("created_at", "-")
+            msg_count = len(session.invocations)
+            status = "活跃" if session.invocations else "空闲"
+            table.add_row(session_id, str(created)[:19], str(msg_count), status)
+        except Exception:
+            table.add_row(session_id, "-", "-", "[red]错误[/red]")
+    
+    console.print(table)
+    
+    if len(sessions) > limit:
+        console.print(f"[dim]还有 {len(sessions) - limit} 个会话未显示[/dim]")
+
+
+@session_app.command("show")
+def show_session(
+    session_id: str = typer.Argument(
+        ...,
+        help="会话 ID",
+    ),
+    config_file: Optional[Path] = typer.Option(
+        None,
+        "--config", "-c",
+        help="配置文件路径",
+    ),
+):
+    """显示会话详情。"""
+    config = load_config(config_file)
+    service = _get_session_service(config)
+    
+    try:
+        session = asyncio.run(service.load(session_id))
+    except Exception as e:
+        console.print(f"[red]无法加载会话: {e}[/red]")
+        raise typer.Exit(1)
+    
+    # 会话信息
+    info = [
+        f"会话 ID: {session.session_id}",
+        f"调用数: {len(session.invocations)}",
+    ]
+    
+    # 元数据
+    if session.metadata:
+        info.append("")
+        info.append("[bold]元数据:[/bold]")
+        for key, value in session.metadata.items():
+            info.append(f"  {key}: {value}")
+    
+    # 调用历史
+    if session.invocations:
+        info.append("")
+        info.append("[bold]最近调用:[/bold]")
+        for inv in session.invocations[-5:]:
+            info.append(f"  - {inv.invocation_id}: {inv.status}")
+    
+    console.print(Panel(
+        "\n".join(info),
+        title=f"会话: {session_id}",
+    ))
+
+
+@session_app.command("delete")
+def delete_session(
+    session_id: str = typer.Argument(
+        ...,
+        help="会话 ID",
+    ),
+    force: bool = typer.Option(
+        False,
+        "--force", "-f",
+        help="强制删除，不询问确认",
+    ),
+    config_file: Optional[Path] = typer.Option(
+        None,
+        "--config", "-c",
+        help="配置文件路径",
+    ),
+):
+    """删除会话。"""
+    config = load_config(config_file)
+    service = _get_session_service(config)
+    
+    if not force:
+        confirm = typer.confirm(f"确定要删除会话 {session_id} 吗？")
+        if not confirm:
+            console.print("[dim]已取消[/dim]")
+            return
+    
+    try:
+        asyncio.run(service.delete(session_id))
+        console.print(f"[green]会话已删除: {session_id}[/green]")
+    except Exception as e:
+        console.print(f"[red]删除失败: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@session_app.command("clear")
+def clear_sessions(
+    force: bool = typer.Option(
+        False,
+        "--force", "-f",
+        help="强制删除，不询问确认",
+    ),
+    older_than: Optional[int] = typer.Option(
+        None,
+        "--older-than",
+        help="删除超过指定天数的会话",
+    ),
+    config_file: Optional[Path] = typer.Option(
+        None,
+        "--config", "-c",
+        help="配置文件路径",
+    ),
+):
+    """清理会话。"""
+    config = load_config(config_file)
+    service = _get_session_service(config)
+    
+    sessions = asyncio.run(service.list())
+    
+    if not sessions:
+        console.print("[dim]暂无会话[/dim]")
+        return
+    
+    to_delete = []
+    
+    if older_than:
+        # 筛选旧会话
+        cutoff = datetime.now().timestamp() - (older_than * 86400)
+        
+        for session_id in sessions:
+            try:
+                session = asyncio.run(service.load(session_id))
+                created = session.metadata.get("created_at")
+                if created:
+                    created_ts = datetime.fromisoformat(created).timestamp()
+                    if created_ts < cutoff:
+                        to_delete.append(session_id)
+            except Exception:
+                pass
+    else:
+        to_delete = sessions
+    
+    if not to_delete:
+        console.print("[dim]没有符合条件的会话[/dim]")
+        return
+    
+    if not force:
+        console.print(f"将删除 {len(to_delete)} 个会话:")
+        for sid in to_delete[:5]:
+            console.print(f"  - {sid}")
+        if len(to_delete) > 5:
+            console.print(f"  ... 还有 {len(to_delete) - 5} 个")
+        
+        confirm = typer.confirm("确定要删除这些会话吗？")
+        if not confirm:
+            console.print("[dim]已取消[/dim]")
+            return
+    
+    # 执行删除
+    deleted = 0
+    for session_id in to_delete:
+        try:
+            asyncio.run(service.delete(session_id))
+            deleted += 1
+        except Exception:
+            pass
+    
+    console.print(f"[green]已删除 {deleted} 个会话[/green]")
+
+
+@session_app.command("resume")
+def resume_session(
+    session_id: str = typer.Argument(
+        ...,
+        help="会话 ID",
+    ),
+    config_file: Optional[Path] = typer.Option(
+        None,
+        "--config", "-c",
+        help="配置文件路径",
+    ),
+):
+    """恢复会话并继续对话。"""
+    from aury.agents.cli.chat import chat_command
+    
+    config = load_config(config_file)
+    
+    # 验证会话存在
+    service = _get_session_service(config)
+    try:
+        asyncio.run(service.load(session_id))
+    except Exception as e:
+        console.print(f"[red]会话不存在: {e}[/red]")
+        raise typer.Exit(1)
+    
+    console.print(f"[dim]恢复会话: {session_id}[/dim]")
+    
+    # 启动对话
+    asyncio.run(chat_command(
+        session_id=session_id,
+        config=config,
+        verbose=False,
+    ))
+
+
+@session_app.command("export")
+def export_session(
+    session_id: str = typer.Argument(
+        ...,
+        help="会话 ID",
+    ),
+    output: Path = typer.Option(
+        None,
+        "--output", "-o",
+        help="输出文件路径",
+    ),
+    format: str = typer.Option(
+        "json",
+        "--format",
+        help="输出格式 (json/yaml)",
+    ),
+    config_file: Optional[Path] = typer.Option(
+        None,
+        "--config", "-c",
+        help="配置文件路径",
+    ),
+):
+    """导出会话数据。"""
+    import json
+    import yaml
+    
+    config = load_config(config_file)
+    service = _get_session_service(config)
+    
+    try:
+        session = asyncio.run(service.load(session_id))
+    except Exception as e:
+        console.print(f"[red]无法加载会话: {e}[/red]")
+        raise typer.Exit(1)
+    
+    # 转换为字典
+    data = {
+        "session_id": session.session_id,
+        "metadata": session.metadata,
+        "invocations": [
+            {
+                "invocation_id": inv.invocation_id,
+                "status": inv.status,
+            }
+            for inv in session.invocations
+        ],
+    }
+    
+    # 格式化输出
+    if format == "yaml":
+        content = yaml.safe_dump(data, allow_unicode=True, default_flow_style=False)
+    else:
+        content = json.dumps(data, ensure_ascii=False, indent=2)
+    
+    # 输出
+    if output:
+        with open(output, "w", encoding="utf-8") as f:
+            f.write(content)
+        console.print(f"[green]已导出到: {output}[/green]")
+    else:
+        console.print(content)

aury/agents/cli/workflow.py

@@ -0,0 +1,276 @@
+"""
+Workflow 命令
+=============
+
+运行和管理 Workflow。
+"""
+import asyncio
+import json
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.table import Table
+
+from aury.agents.cli.config import load_config
+
+workflow_app = typer.Typer(help="Workflow 相关命令")
+console = Console()
+
+
+@workflow_app.command("run")
+def run_workflow(
+    workflow_file: Path = typer.Argument(
+        ...,
+        help="Workflow 定义文件路径（.py 或 .yaml）",
+    ),
+    input_data: Optional[str] = typer.Option(
+        None,
+        "--input", "-i",
+        help="输入数据（JSON 格式）",
+    ),
+    config_file: Optional[Path] = typer.Option(
+        None,
+        "--config", "-c",
+        help="配置文件路径",
+    ),
+    verbose: bool = typer.Option(
+        False,
+        "--verbose", "-v",
+        help="显示详细输出",
+    ),
+    dry_run: bool = typer.Option(
+        False,
+        "--dry-run",
+        help="模拟运行，不实际执行",
+    ),
+):
+    """
+    运行 Workflow。
+    
+    示例:
+        aury-agent workflow run pipeline.py
+        aury-agent workflow run pipeline.yaml --input '{"data": "test"}'
+    """
+    # 加载配置
+    cfg = load_config(config_file)
+    
+    if not workflow_file.exists():
+        console.print(f"[red]错误: Workflow 文件不存在: {workflow_file}[/red]")
+        raise typer.Exit(1)
+    
+    # 解析输入
+    input_dict = {}
+    if input_data:
+        try:
+            input_dict = json.loads(input_data)
+        except json.JSONDecodeError as e:
+            console.print(f"[red]错误: 无效的 JSON 输入: {e}[/red]")
+            raise typer.Exit(1)
+    
+    console.print(f"[bold]运行 Workflow: {workflow_file}[/bold]")
+    
+    if dry_run:
+        console.print("[yellow]模拟运行模式[/yellow]")
+        _dry_run_workflow(workflow_file, input_dict, verbose)
+        return
+    
+    # 实际运行
+    asyncio.run(_execute_workflow(workflow_file, input_dict, cfg, verbose))
+
+
+async def _execute_workflow(
+    workflow_file: Path,
+    input_data: dict,
+    config: dict,
+    verbose: bool,
+):
+    """执行 Workflow。"""
+    from aury.agents.workflow import WorkflowExecutor
+    from aury.agents.core import Session, InvocationContext
+    
+    # 加载 Workflow
+    workflow = await _load_workflow(workflow_file)
+    
+    if workflow is None:
+        console.print("[red]无法加载 Workflow[/red]")
+        return
+    
+    console.print(f"[dim]Workflow: {workflow.name}[/dim]")
+    console.print(f"[dim]步骤数: {len(workflow.step_map)}[/dim]")
+    
+    # 创建上下文
+    session = Session(session_id=f"workflow-{workflow.name}")
+    context = InvocationContext(session=session)
+    
+    # 创建执行器
+    executor = WorkflowExecutor(workflow)
+    
+    # 执行
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        task = progress.add_task("执行中...", total=None)
+        
+        try:
+            result = await executor.execute(context, input_data=input_data)
+            progress.update(task, description="完成")
+        except Exception as e:
+            progress.update(task, description=f"[red]失败: {e}[/red]")
+            raise
+    
+    # 显示结果
+    console.print()
+    
+    if result.success:
+        console.print(Panel(
+            f"[green]Workflow 执行成功[/green]\n\n"
+            f"完成步骤: {', '.join(result.state.get_completed_steps())}",
+            title="结果",
+        ))
+    else:
+        console.print(Panel(
+            f"[red]Workflow 执行失败[/red]\n\n"
+            f"失败步骤: {', '.join([s for s in result.state.step_statuses if result.state.is_step_failed(s)])}",
+            title="结果",
+        ))
+    
+    # 详细输出
+    if verbose:
+        console.print("\n[bold]步骤详情:[/bold]")
+        for step_id, status in result.state.step_statuses.items():
+            step_result = result.state.get_step_result(step_id)
+            console.print(f"  {step_id}: {status}")
+            if step_result:
+                console.print(f"    结果: {step_result}")
+
+
+async def _load_workflow(workflow_file: Path):
+    """加载 Workflow 定义。"""
+    if workflow_file.suffix == ".py":
+        # 从 Python 文件加载
+        import importlib.util
+        
+        spec = importlib.util.spec_from_file_location("workflow_module", workflow_file)
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+        
+        # 查找 Workflow 对象或构建函数
+        if hasattr(module, "workflow"):
+            return module.workflow
+        elif hasattr(module, "build_workflow"):
+            return module.build_workflow()
+        elif hasattr(module, "create_workflow"):
+            return module.create_workflow()
+        else:
+            console.print("[yellow]警告: 未找到 workflow 对象或构建函数[/yellow]")
+            return None
+    
+    elif workflow_file.suffix in [".yaml", ".yml"]:
+        # 从 YAML 文件加载
+        # TODO: 实现 YAML 格式的 Workflow 定义
+        console.print("[yellow]YAML Workflow 格式暂未支持[/yellow]")
+        return None
+    
+    else:
+        console.print(f"[red]不支持的文件格式: {workflow_file.suffix}[/red]")
+        return None
+
+
+def _dry_run_workflow(workflow_file: Path, input_data: dict, verbose: bool):
+    """模拟运行 Workflow。"""
+    console.print("\n[dim]模拟运行步骤:[/dim]")
+    console.print(f"  1. 加载 Workflow: {workflow_file}")
+    console.print(f"  2. 验证输入: {input_data or '(无输入)'}")
+    console.print("  3. 执行各步骤 (模拟)")
+    console.print("  4. 返回结果")
+
+
+@workflow_app.command("list")
+def list_workflows(
+    directory: Path = typer.Option(
+        Path("."),
+        "--dir", "-d",
+        help="搜索目录",
+    ),
+):
+    """列出可用的 Workflow 文件。"""
+    workflows = []
+    
+    # 搜索 Python 文件
+    for py_file in directory.glob("**/*.py"):
+        if "workflow" in py_file.name.lower():
+            workflows.append(py_file)
+    
+    # 搜索 YAML 文件
+    for yaml_file in directory.glob("**/*.yaml"):
+        if "workflow" in yaml_file.name.lower():
+            workflows.append(yaml_file)
+    
+    if not workflows:
+        console.print("[dim]未找到 Workflow 文件[/dim]")
+        return
+    
+    table = Table(title="可用 Workflow")
+    table.add_column("文件", style="cyan")
+    table.add_column("类型")
+    
+    for wf in workflows:
+        file_type = "Python" if wf.suffix == ".py" else "YAML"
+        table.add_row(str(wf.relative_to(directory)), file_type)
+    
+    console.print(table)
+
+
+@workflow_app.command("validate")
+def validate_workflow(
+    workflow_file: Path = typer.Argument(
+        ...,
+        help="Workflow 定义文件路径",
+    ),
+):
+    """验证 Workflow 定义。"""
+    if not workflow_file.exists():
+        console.print(f"[red]文件不存在: {workflow_file}[/red]")
+        raise typer.Exit(1)
+    
+    console.print(f"验证 Workflow: {workflow_file}")
+    
+    try:
+        workflow = asyncio.run(_load_workflow(workflow_file))
+        
+        if workflow is None:
+            console.print("[red]验证失败: 无法加载 Workflow[/red]")
+            raise typer.Exit(1)
+        
+        # 验证
+        errors = []
+        
+        if not workflow.entry_step_id:
+            errors.append("未定义入口步骤")
+        
+        if not workflow.step_map:
+            errors.append("没有定义任何步骤")
+        
+        if workflow.entry_step_id and workflow.entry_step_id not in workflow.step_map:
+            errors.append(f"入口步骤不存在: {workflow.entry_step_id}")
+        
+        if errors:
+            console.print("[red]验证失败:[/red]")
+            for err in errors:
+                console.print(f"  - {err}")
+            raise typer.Exit(1)
+        
+        console.print(f"[green]验证通过[/green]")
+        console.print(f"  名称: {workflow.name}")
+        console.print(f"  步骤数: {len(workflow.step_map)}")
+        console.print(f"  入口: {workflow.entry_step_id}")
+        
+    except Exception as e:
+        console.print(f"[red]验证失败: {e}[/red]")
+        raise typer.Exit(1)

aury/agents/context_providers/__init__.py

@@ -0,0 +1,66 @@
+"""ContextProvider system for context engineering.
+
+ContextProviders provide a unified abstraction for fetching LLM context:
+- Messages (conversation history)
+- Memory (long-term memory summaries/recalls)
+- Artifacts (with pluggable loaders for different types)
+- SubAgents (sub-agent configurations)
+- Skills (capability descriptions)
+
+Core Design:
+- Provider: ONLY responsible for FETCHING context (read)
+- Middleware: Responsible for WRITING/SAVING (via hooks like on_message_save)
+- Manager: Service layer providing APIs for both Provider and Middleware
+
+- Each ContextProvider implements `fetch(ctx) -> AgentContext`
+- AgentContext contains: system_content, user_content, messages, tools, subagents, skills
+- Multiple AgentContexts are merged before LLM call
+
+Usage:
+    agent = ReactAgent.create(
+        llm=llm,
+        tools=[my_tool],
+        providers=[
+            ArtifactContextProvider(backend=artifact_backend),
+            MemoryContextProvider(memory_manager=memory),
+        ],
+        enable_history=True,  # Auto-creates MessageContextProvider + MessageBackendMiddleware
+    )
+
+Built-in ContextProviders:
+- MessageContextProvider: Fetch conversation history
+- MemoryContextProvider: Fetch memory summaries/recalls
+- ArtifactContextProvider: Artifact index with ReadArtifactTool + pluggable loaders
+- SubAgentContextProvider: Provides sub-agent configurations
+- SkillContextProvider: Skill descriptions in system prompt
+"""
+from .base import ContextProvider, AgentContext, BaseContextProvider
+from .message import MessageContextProvider
+from .memory import MemoryContextProvider
+from .artifact import (
+    ArtifactContextProvider,
+    ArtifactLoader,
+    ReadArtifactTool,
+    register_loader,
+    get_loader,
+)
+from .subagent import SubAgentContextProvider
+from .skill import SkillContextProvider
+
+__all__ = [
+    # Base protocol
+    "ContextProvider",
+    "AgentContext",
+    "BaseContextProvider",
+    # Built-in providers
+    "MessageContextProvider",
+    "MemoryContextProvider",
+    "ArtifactContextProvider",
+    "SubAgentContextProvider",
+    "SkillContextProvider",
+    # Artifact utilities
+    "ArtifactLoader",
+    "ReadArtifactTool",
+    "register_loader",
+    "get_loader",
+]