base-agentkit 0.1.0__tar.gz → 0.1.2__tar.gz

base_agentkit-0.1.2/PKG-INFO

@@ -0,0 +1,159 @@
+Metadata-Version: 2.4
+Name: base-agentkit
+Version: 0.1.2
+Summary: Workspace-isolated Python framework for building tool-using LLM agents.
+Keywords: agents,llm,tool-calling,workspace,ai
+Author: sii-nyc
+Author-email: sii-nyc <253108120111@sii.edu.cn>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Dist: openai>=2.21.0
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: requests>=2.32.5
+Requires-Python: >=3.12
+Project-URL: Homepage, https://github.com/Inkjourney/agentkit
+Project-URL: Repository, https://github.com/Inkjourney/agentkit
+Project-URL: Documentation, https://inkjourney.github.io/agentkit/
+Project-URL: Issues, https://github.com/Inkjourney/agentkit/issues
+Description-Content-Type: text/markdown
+
+# AgentKit
+
+[中文版本](docs/README.zh-CN.md)
+
+AgentKit is a general-purpose framework for tool-using LLM agents. It provides
+workspace isolation, a unified LLM abstraction, a tool-execution loop, and both
+CLI and Python SDK entry points.
+
+## Current Capabilities
+
+- Strong workspace isolation: all agent-visible file access goes through
+  `WorkspaceFS`
+- Unified LLM abstraction:
+  `ConversationItem` / `ConversationState` / `UnifiedLLMRequest` /
+  `UnifiedLLMResponse`
+- Provider support (sync, non-streaming, text)
+  - OpenAI (`responses` / `chat_completions`)
+  - Anthropic (`messages`)
+  - Gemini (`generateContent`)
+  - Qwen (OpenAI-compatible `chat_completions`)
+  - vLLM (OpenAI-compatible `chat_completions`)
+- Registry-based tool system with built-in tools under
+  `src/agentkit/tools/library/` and custom tool loading from project
+  file/directory entries
+- Agent loop that coordinates model reasoning and tool execution under step/time
+  budgets
+- Run logs written to `workspace/logs/run_<run_id>.jsonl`
+
+## Status
+
+- The repository includes unit tests for the agent loop, CLI, tool system,
+  runlog, and the OpenAI / Anthropic / Gemini / Qwen / vLLM provider adapters
+- There is no smoke-test coverage against live upstream APIs yet, so a final
+  end-to-end validation against the target model is still recommended before
+  production use
+
+## Documentation
+
+Full documentation lives under `docs/agentkit/`.
+The published site is [GitHub Pages](https://inkjourney.github.io/agentkit/) and
+deploys automatically from pushes to `main`.
+
+## Install From Source
+
+```bash
+uv sync
+uv run agentkit --help
+```
+
+## Install From PyPI
+
+```bash
+pip install base-agentkit
+agentkit --help
+```
+
+The import path and CLI command stay the same after installation:
+
+```python
+from agentkit import create_agent
+```
+
+## Example Configuration
+
+### vLLM
+
+```yaml
+workspace:
+  root: "./vllm_workspace"
+
+provider:
+  kind: "vllm"
+  model: "glm-5"
+  openai_api_variant: "chat_completions"
+  conversation_mode: "auto"
+  base_url: "http://localhost:8000/v1"
+  api_key: "empty"
+  temperature: 0.8
+  timeout_s: 600
+  retries: 2
+  enable_thinking: true
+
+agent:
+  system_prompt: "You are a helpful agent. Use tools when needed."
+  budget:
+    max_steps: 200
+    time_budget_s: 1800
+    max_input_chars: 180000
+
+tools:
+  entries:
+    - "./tools"
+  allowed:
+    - "view"
+    - "create_file"
+    - "str_replace"
+    - "word_count"
+
+runlog:
+  enabled: true
+  redact: true
+  max_text_chars: 20000
+```
+
+## Run From The CLI
+
+```bash
+export OPENAI_API_KEY="your-key"
+uv run agentkit --config path/to/config.yaml run --task "List the files in the current workspace"
+```
+
+## Python SDK
+
+```python
+from agentkit import create_agent
+
+agent = create_agent("path/to/config.yaml")
+report = agent.run("Create notes/todo.txt in the workspace and write today's plan")
+print(report.final_output)
+```
+
+## Project Layout
+
+The core implementation lives under `src/agentkit/`:
+
+- `config/`: configuration schema and loader
+- `workspace/`: strict filesystem isolation and workspace layout
+- `llm/`: unified abstractions, provider base/factory, and adapters
+- `tools/`: tool abstractions, registry, and autoloading
+- `agent/`: budgets, reports, runtime, and the agent loop
+- `runlog/`: structured events, event sinks, and JSONL runlogs
+- `cli/`: command-line entry point

base_agentkit-0.1.2/README.md

@@ -0,0 +1,132 @@
+# AgentKit
+
+[中文版本](docs/README.zh-CN.md)
+
+AgentKit is a general-purpose framework for tool-using LLM agents. It provides
+workspace isolation, a unified LLM abstraction, a tool-execution loop, and both
+CLI and Python SDK entry points.
+
+## Current Capabilities
+
+- Strong workspace isolation: all agent-visible file access goes through
+  `WorkspaceFS`
+- Unified LLM abstraction:
+  `ConversationItem` / `ConversationState` / `UnifiedLLMRequest` /
+  `UnifiedLLMResponse`
+- Provider support (sync, non-streaming, text)
+  - OpenAI (`responses` / `chat_completions`)
+  - Anthropic (`messages`)
+  - Gemini (`generateContent`)
+  - Qwen (OpenAI-compatible `chat_completions`)
+  - vLLM (OpenAI-compatible `chat_completions`)
+- Registry-based tool system with built-in tools under
+  `src/agentkit/tools/library/` and custom tool loading from project
+  file/directory entries
+- Agent loop that coordinates model reasoning and tool execution under step/time
+  budgets
+- Run logs written to `workspace/logs/run_<run_id>.jsonl`
+
+## Status
+
+- The repository includes unit tests for the agent loop, CLI, tool system,
+  runlog, and the OpenAI / Anthropic / Gemini / Qwen / vLLM provider adapters
+- There is no smoke-test coverage against live upstream APIs yet, so a final
+  end-to-end validation against the target model is still recommended before
+  production use
+
+## Documentation
+
+Full documentation lives under `docs/agentkit/`.
+The published site is [GitHub Pages](https://inkjourney.github.io/agentkit/) and
+deploys automatically from pushes to `main`.
+
+## Install From Source
+
+```bash
+uv sync
+uv run agentkit --help
+```
+
+## Install From PyPI
+
+```bash
+pip install base-agentkit
+agentkit --help
+```
+
+The import path and CLI command stay the same after installation:
+
+```python
+from agentkit import create_agent
+```
+
+## Example Configuration
+
+### vLLM
+
+```yaml
+workspace:
+  root: "./vllm_workspace"
+
+provider:
+  kind: "vllm"
+  model: "glm-5"
+  openai_api_variant: "chat_completions"
+  conversation_mode: "auto"
+  base_url: "http://localhost:8000/v1"
+  api_key: "empty"
+  temperature: 0.8
+  timeout_s: 600
+  retries: 2
+  enable_thinking: true
+
+agent:
+  system_prompt: "You are a helpful agent. Use tools when needed."
+  budget:
+    max_steps: 200
+    time_budget_s: 1800
+    max_input_chars: 180000
+
+tools:
+  entries:
+    - "./tools"
+  allowed:
+    - "view"
+    - "create_file"
+    - "str_replace"
+    - "word_count"
+
+runlog:
+  enabled: true
+  redact: true
+  max_text_chars: 20000
+```
+
+## Run From The CLI
+
+```bash
+export OPENAI_API_KEY="your-key"
+uv run agentkit --config path/to/config.yaml run --task "List the files in the current workspace"
+```
+
+## Python SDK
+
+```python
+from agentkit import create_agent
+
+agent = create_agent("path/to/config.yaml")
+report = agent.run("Create notes/todo.txt in the workspace and write today's plan")
+print(report.final_output)
+```
+
+## Project Layout
+
+The core implementation lives under `src/agentkit/`:
+
+- `config/`: configuration schema and loader
+- `workspace/`: strict filesystem isolation and workspace layout
+- `llm/`: unified abstractions, provider base/factory, and adapters
+- `tools/`: tool abstractions, registry, and autoloading
+- `agent/`: budgets, reports, runtime, and the agent loop
+- `runlog/`: structured events, event sinks, and JSONL runlogs
+- `cli/`: command-line entry point

{base_agentkit-0.1.0 → base_agentkit-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "base-agentkit"
-version = "0.1.0"
+version = "0.1.2"
 description = "Workspace-isolated Python framework for building tool-using LLM agents."
 readme = "README.md"
 authors = [{ name = "sii-nyc", email = "253108120111@sii.edu.cn" }]
@@ -30,7 +30,7 @@ agentkit = "agentkit.cli.main:main"
 [project.urls]
 Homepage = "https://github.com/Inkjourney/agentkit"
 Repository = "https://github.com/Inkjourney/agentkit"
-Documentation = "https://github.com/Inkjourney/agentkit/tree/main/docs/agentkit"
+Documentation = "https://inkjourney.github.io/agentkit/"
 Issues = "https://github.com/Inkjourney/agentkit/issues"
 
 [dependency-groups]

{base_agentkit-0.1.0 → base_agentkit-0.1.2}/src/agentkit/agent/agent.py

@@ -25,7 +25,7 @@ from agentkit.llm.types import (
 )
 from agentkit.llm.usage import merge_usage, usage_to_payload
 from agentkit.runlog import JsonlRunLogSink
-from agentkit.tools.loader import load_tools_from_library
+from agentkit.tools.loader import load_tools_from_entries, load_tools_from_library
 from agentkit.tools.registry import ToolRegistry
 from agentkit.runlog.recorder import RunRecorder
 from agentkit.workspace.fs import WorkspaceFS
@@ -78,9 +78,10 @@ class Agent:
         # Build the configured LLM provider
         provider = build_provider(config.provider)
 
-        # Load tools from the workspace library and register them
+        # Load built-in tools plus any configured external tool entries.
         registry = ToolRegistry()
         registry.register_many(load_tools_from_library(fs))
+        registry.register_many(load_tools_from_entries(config.tools.entries, fs))
 
         # Create tool runtime with allowlist filtering
         tool_runtime = AgentToolRuntime(registry, config.tools.allowed)

{base_agentkit-0.1.0 → base_agentkit-0.1.2}/src/agentkit/config/loader.py

@@ -31,7 +31,8 @@ def load_config(
     overrides: Mapping[str, Any] | None = None,
 ) -> AgentkitConfig:
     """Load, merge, expand, and validate framework configuration."""
-    raw = _read_raw_config(path)
+    config_path = Path(path).expanduser()
+    raw = _read_raw_config(config_path)
     if overrides:
         raw = _deep_merge(raw, dict(overrides))
     raw = _expand_env(raw)
@@ -46,6 +47,10 @@ def load_config(
         agent = AgentConfig(budget=budget, **agent_data)
 
         tools = ToolConfig(**raw.get("tools", {}))
+        tools.entries = _resolve_tool_entries(
+            tools.entries,
+            base_dir=config_path.resolve(strict=False).parent,
+        )
         runlog = RunLogConfig(**raw.get("runlog", {}))
     except TypeError as exc:
         raise ConfigError(f"Invalid configuration fields: {exc}") from exc
@@ -106,3 +111,14 @@ def _deep_merge(base: dict[str, Any], override: dict[str, Any]) -> dict[str, Any
         else:
             merged[key] = value
     return merged
+
+
+def _resolve_tool_entries(entries: list[str], *, base_dir: Path) -> list[str]:
+    """Resolve configured tool entry paths relative to the config file."""
+    resolved_entries: list[str] = []
+    for entry in entries:
+        candidate = Path(entry).expanduser()
+        if not candidate.is_absolute():
+            candidate = base_dir / candidate
+        resolved_entries.append(str(candidate.resolve(strict=False)))
+    return resolved_entries

{base_agentkit-0.1.0 → base_agentkit-0.1.2}/src/agentkit/config/schema.py

@@ -122,6 +122,17 @@ class ToolConfig:
     allowed: list[str] = field(default_factory=list)
     entries: list[str] = field(default_factory=list)
 
+    def __post_init__(self) -> None:
+        """Validate allowlist and external entry shapes."""
+        if not isinstance(self.allowed, list) or any(
+            not isinstance(name, str) or not name.strip() for name in self.allowed
+        ):
+            raise ConfigError("tools.allowed must be a list of non-empty strings.")
+        if not isinstance(self.entries, list) or any(
+            not isinstance(entry, str) or not entry.strip() for entry in self.entries
+        ):
+            raise ConfigError("tools.entries must be a list of non-empty strings.")
+
 
 @dataclass(slots=True)
 class RunLogConfig:

{base_agentkit-0.1.0 → base_agentkit-0.1.2}/src/agentkit/constants.py

@@ -13,9 +13,11 @@ DEFAULT_TIME_BUDGET_S = 300
 DEFAULT_MAX_INPUT_CHARS = 20_000
 
 SENSITIVE_KEYS: tuple[str, ...] = (
+    "access_token",
     "api_key",
     "apikey",
-    "secret",
-    "password",
     "authorization",
+    "password",
+    "refresh_token",
+    "secret",
 )

{base_agentkit-0.1.0 → base_agentkit-0.1.2}/src/agentkit/tools/__init__.py

@@ -1,7 +1,7 @@
 """Public tool abstraction and registry exports."""
 
 from .base import FunctionTool, Tool
-from .loader import load_tools_from_library
+from .loader import load_tools_from_entries, load_tools_from_library
 from .registry import ToolRegistry
 from .types import ToolCallOutcome, ToolInvocation, ToolModelError
 
@@ -12,5 +12,6 @@ __all__ = [
     "ToolInvocation",
     "ToolModelError",
     "ToolRegistry",
+    "load_tools_from_entries",
     "load_tools_from_library",
 ]

base_agentkit-0.1.2/src/agentkit/tools/loader.py

@@ -0,0 +1,246 @@
+"""Automatic loading for built-in and user-provided tool modules."""
+
+from __future__ import annotations
+
+import importlib
+import importlib.util
+import inspect
+import itertools
+import pkgutil
+import sys
+from importlib.machinery import ModuleSpec
+from pathlib import Path
+from types import ModuleType
+from typing import Any, Iterable
+
+from agentkit.errors import ToolError
+from agentkit.tools.base import Tool
+from agentkit.workspace.fs import WorkspaceFS
+
+TOOLS_LIBRARY_PACKAGE = "agentkit.tools.library"
+_USER_TOOLS_PACKAGE_PREFIX = "_agentkit_user_tools"
+_USER_TOOLS_COUNTER = itertools.count()
+
+
+def load_tools_from_library(fs: WorkspaceFS) -> list[Tool]:
+    """Load all tools exposed by modules under ``agentkit.tools.library``.
+
+    Tool modules can expose tools via:
+    - ``build_tools(fs)`` (or ``build_tools()``)
+    - ``TOOLS`` module variable
+
+    Args:
+        fs: Workspace filesystem injected into callable tool factories.
+
+    Returns:
+        list[Tool]: Flattened list of tools from all library modules.
+    """
+    package = importlib.import_module(TOOLS_LIBRARY_PACKAGE)
+    package_path = getattr(package, "__path__", None)
+    if package_path is None:
+        return []
+
+    loaded: list[Tool] = []
+    for module_info in sorted(pkgutil.iter_modules(package_path), key=lambda m: m.name):
+        if module_info.name.startswith("_"):
+            continue
+        module_name = f"{TOOLS_LIBRARY_PACKAGE}.{module_info.name}"
+        module = importlib.import_module(module_name)
+        loaded.extend(_load_from_module(module, fs, module_name=module_name))
+    return loaded
+
+
+def load_tools_from_entries(
+    entries: Iterable[str | Path], fs: WorkspaceFS
+) -> list[Tool]:
+    """Load tools from configured file or directory entries.
+
+    Args:
+        entries: Filesystem paths pointing to Python files or directories that
+            contain Python tool modules.
+        fs: Workspace filesystem injected into callable tool factories.
+
+    Returns:
+        list[Tool]: Flattened list of tools discovered from all configured entries.
+
+    Raises:
+        agentkit.errors.ToolError: If an entry is missing, unsupported, or does not
+            define any tools.
+    """
+    loaded: list[Tool] = []
+    package_names: dict[Path, str] = {}
+    for entry in entries:
+        path = Path(entry).expanduser().resolve(strict=False)
+        loaded.extend(_load_tools_from_entry(path, fs, package_names=package_names))
+    return loaded
+
+
+def _load_from_module(module: Any, fs: WorkspaceFS, *, module_name: str) -> list[Tool]:
+    """Extract tools from one library module."""
+    if hasattr(module, "build_tools"):
+        return _coerce_to_tools(getattr(module, "build_tools"), fs, module_name)
+    if hasattr(module, "TOOLS"):
+        return _coerce_to_tools(getattr(module, "TOOLS"), fs, module_name)
+    return []
+
+
+def _coerce_to_tools(candidate: Any, fs: WorkspaceFS, module_name: str) -> list[Tool]:
+    """Normalize supported tool declarations into ``list[Tool]``."""
+    if isinstance(candidate, Tool):
+        return [candidate]
+
+    if callable(candidate):
+        built: Any
+        try:
+            signature = inspect.signature(candidate)
+            if len(signature.parameters) == 0:
+                built = candidate()
+            else:
+                built = candidate(fs)
+        except ValueError:
+            built = candidate(fs)
+        return _coerce_to_tools(built, fs, module_name)
+
+    if isinstance(candidate, Iterable) and not isinstance(
+        candidate, (str, bytes, dict)
+    ):
+        tools = list(candidate)
+        if all(isinstance(item, Tool) for item in tools):
+            return tools
+
+    raise ToolError(
+        f"Module '{module_name}' must expose Tool, Iterable[Tool], build_tools(...), or TOOLS."
+    )
+
+
+def _load_tools_from_entry(
+    path: Path,
+    fs: WorkspaceFS,
+    *,
+    package_names: dict[Path, str],
+) -> list[Tool]:
+    """Load tools from one configured filesystem entry."""
+    if not path.exists():
+        raise ToolError(f"Tool entry not found: {path}")
+    if path.is_file():
+        return _load_tools_from_file_entry(path, fs, package_names=package_names)
+    if path.is_dir():
+        return _load_tools_from_directory_entry(path, fs, package_names=package_names)
+    raise ToolError(f"Unsupported tool entry type: {path}")
+
+
+def _load_tools_from_file_entry(
+    path: Path,
+    fs: WorkspaceFS,
+    *,
+    package_names: dict[Path, str],
+) -> list[Tool]:
+    """Load tools from one Python file entry."""
+    if path.suffix != ".py":
+        raise ToolError(f"Tool entry file must be a Python module: {path}")
+
+    package_name = _ensure_entry_package(path.parent, package_names=package_names)
+    module_name = f"{package_name}.{_sanitize_module_name(path.stem)}"
+    module = _load_module_from_path(path, module_name=module_name)
+    tools = _load_from_module(module, fs, module_name=str(path))
+    if not tools:
+        raise ToolError(f"Tool entry did not define any tools: {path}")
+    return tools
+
+
+def _load_tools_from_directory_entry(
+    path: Path,
+    fs: WorkspaceFS,
+    *,
+    package_names: dict[Path, str],
+) -> list[Tool]:
+    """Load tools from all eligible Python modules in one directory entry."""
+    package_name = _ensure_entry_package(path, package_names=package_names)
+    package_module = sys.modules[package_name]
+    loaded = _load_from_module(package_module, fs, module_name=str(path / "__init__.py"))
+
+    for child in sorted(path.iterdir(), key=lambda item: item.name):
+        if not child.is_file():
+            continue
+        if child.suffix != ".py":
+            continue
+        if child.name == "__init__.py" or child.name.startswith("_"):
+            continue
+        module_name = f"{package_name}.{_sanitize_module_name(child.stem)}"
+        module = _load_module_from_path(child, module_name=module_name)
+        loaded.extend(_load_from_module(module, fs, module_name=str(child)))
+
+    if not loaded:
+        raise ToolError(f"Tool entry did not define any tools: {path}")
+    return loaded
+
+
+def _ensure_entry_package(path: Path, *, package_names: dict[Path, str]) -> str:
+    """Create or reuse a synthetic package namespace for one filesystem root."""
+    root = path.resolve(strict=False)
+    existing = package_names.get(root)
+    if existing is not None:
+        return existing
+
+    package_name = _next_dynamic_package_name(root)
+    init_file = root / "__init__.py"
+    if init_file.is_file():
+        _load_module_from_path(
+            init_file,
+            module_name=package_name,
+            submodule_search_locations=[str(root)],
+        )
+    else:
+        module = ModuleType(package_name)
+        module.__file__ = str(root)
+        module.__package__ = package_name
+        module.__path__ = [str(root)]  # type: ignore[attr-defined]
+        spec = ModuleSpec(package_name, loader=None, is_package=True)
+        spec.submodule_search_locations = [str(root)]
+        module.__spec__ = spec
+        sys.modules[package_name] = module
+
+    package_names[root] = package_name
+    return package_name
+
+
+def _load_module_from_path(
+    path: Path,
+    *,
+    module_name: str,
+    submodule_search_locations: list[str] | None = None,
+) -> ModuleType:
+    """Import one Python file from disk under a caller-controlled module name."""
+    spec = importlib.util.spec_from_file_location(
+        module_name,
+        path,
+        submodule_search_locations=submodule_search_locations,
+    )
+    if spec is None or spec.loader is None:
+        raise ToolError(f"Could not create an import spec for tool module: {path}")
+
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[module_name] = module
+    try:
+        spec.loader.exec_module(module)
+    except Exception as exc:
+        sys.modules.pop(module_name, None)
+        raise ToolError(f"Failed to import tool module '{path}': {exc}") from exc
+    return module
+
+
+def _next_dynamic_package_name(path: Path) -> str:
+    """Return a unique synthetic package name for one configured tool root."""
+    suffix = next(_USER_TOOLS_COUNTER)
+    slug = _sanitize_module_name(path.stem or "entry")
+    return f"{_USER_TOOLS_PACKAGE_PREFIX}_{suffix}_{slug}"
+
+
+def _sanitize_module_name(name: str) -> str:
+    """Normalize arbitrary filenames into valid Python identifier segments."""
+    cleaned = "".join(ch if ch.isalnum() or ch == "_" else "_" for ch in name)
+    if not cleaned:
+        return "tool_module"
+    if cleaned[0].isdigit():
+        return f"_{cleaned}"
+    return cleaned

base_agentkit-0.1.0/PKG-INFO

@@ -1,142 +0,0 @@
-Metadata-Version: 2.4
-Name: base-agentkit
-Version: 0.1.0
-Summary: Workspace-isolated Python framework for building tool-using LLM agents.
-Keywords: agents,llm,tool-calling,workspace,ai
-Author: sii-nyc
-Author-email: sii-nyc <253108120111@sii.edu.cn>
-License-Expression: Apache-2.0
-License-File: LICENSE
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Typing :: Typed
-Requires-Dist: openai>=2.21.0
-Requires-Dist: pydantic>=2.12.5
-Requires-Dist: pyyaml>=6.0.3
-Requires-Dist: requests>=2.32.5
-Requires-Python: >=3.12
-Project-URL: Homepage, https://github.com/Inkjourney/agentkit
-Project-URL: Repository, https://github.com/Inkjourney/agentkit
-Project-URL: Documentation, https://github.com/Inkjourney/agentkit/tree/main/docs/agentkit
-Project-URL: Issues, https://github.com/Inkjourney/agentkit/issues
-Description-Content-Type: text/markdown
-
-# AgentKit
-
-一个基于 LLM 的通用 Agent 框架，支持 workspace 隔离、统一 LLM 抽象、工具调用循环、CLI 与 Python SDK。
-
-## 当前能力
-
-- workspace 强隔离：所有读写通过 `WorkspaceFS`
-- 统一 LLM 抽象：`ConversationItem` / `ConversationState` / `UnifiedLLMRequest` / `UnifiedLLMResponse`
-- Provider 支持（同步、非流式、文本）
-  - OpenAI (`responses` / `chat_completions`)
-  - Anthropic (`messages`)
-  - Gemini (`generateContent`)
-  - Qwen（OpenAI-compatible `chat_completions`）
-  - vLLM（OpenAI-compatible `chat_completions`）
-- 工具系统：注册式工具机制，工具模块放在 `src/agentkit/tools/library/`
-- Agent loop：模型推理与工具执行闭环，受 step/time budget 约束
-- runlog：每次任务写入 `workspace/logs/run_<run_id>.jsonl`
-
-## 状态
-
-- 当前仓库包含针对 Agent loop、CLI、工具系统、runlog 以及 OpenAI / Anthropic / Gemini / Qwen / vLLM provider 适配层的单元测试
-- 尚未提供针对真实上游 API 的集成 smoke test，因此正式发布前仍建议用目标模型做一次端到端验证
-
-## 文档
-
-详细使用说明和完整文档见 `docs/agentkit/`。
-
-## 从源码安装
-
-```bash
-uv sync
-uv run agentkit --help
-```
-
-## 从 PyPI 安装
-
-```bash
-pip install base-agentkit
-agentkit --help
-```
-
-安装后的导入路径和 CLI 名称保持不变：
-
-```python
-from agentkit import create_agent
-```
-
-## 配置示例
-
-### vLLM
-
-```yaml
-workspace:
-  root: "./vllm_workspace"
-
-provider:
-  kind: "vllm"
-  model: "glm-5"
-  openai_api_variant: "chat_completions"
-  conversation_mode: "auto"
-  base_url: "http://localhost:8000/v1"
-  api_key: "empty"
-  temperature: 0.8
-  timeout_s: 600
-  retries: 2
-  enable_thinking: true
-
-agent:
-  system_prompt: "You are a helpful agent. Use tools when needed."
-  budget:
-    max_steps: 200
-    time_budget_s: 1800
-    max_input_chars: 180000
-
-tools:
-  allowed:
-    - "view"
-    - "create_file"
-    - "str_replace"
-    - "word_count"
-
-runlog:
-  enabled: true
-  redact: true
-  max_text_chars: 20000
-```
-
-## CLI 运行
-
-```bash
-export OPENAI_API_KEY="your-key"
-uv run agentkit --config path/to/config.yaml run --task "列出当前 workspace 的文件"
-```
-
-## Python SDK
-
-```python
-from agentkit import create_agent
-
-agent = create_agent("path/to/config.yaml")
-report = agent.run("在 workspace 里新建 notes/todo.txt 并写入今天计划")
-print(report.final_output)
-```
-
-## 项目结构
-
-核心实现位于 `src/agentkit/`：
-
-- `config/`: 配置结构与加载
-- `workspace/`: 强隔离文件系统和目录布局
-- `llm/`: 统一抽象、provider base/factory 与四平台 adapter
-- `tools/`: 工具抽象、注册表与自动加载
-- `agent/`: budget、report、runtime、Agent loop
-- `runlog/`: 结构化事件、event sink 与 JSONL runlog
-- `cli/`: 命令行入口

base_agentkit-0.1.0/README.md

@@ -1,115 +0,0 @@
-# AgentKit
-
-一个基于 LLM 的通用 Agent 框架，支持 workspace 隔离、统一 LLM 抽象、工具调用循环、CLI 与 Python SDK。
-
-## 当前能力
-
-- workspace 强隔离：所有读写通过 `WorkspaceFS`
-- 统一 LLM 抽象：`ConversationItem` / `ConversationState` / `UnifiedLLMRequest` / `UnifiedLLMResponse`
-- Provider 支持（同步、非流式、文本）
-  - OpenAI (`responses` / `chat_completions`)
-  - Anthropic (`messages`)
-  - Gemini (`generateContent`)
-  - Qwen（OpenAI-compatible `chat_completions`）
-  - vLLM（OpenAI-compatible `chat_completions`）
-- 工具系统：注册式工具机制，工具模块放在 `src/agentkit/tools/library/`
-- Agent loop：模型推理与工具执行闭环，受 step/time budget 约束
-- runlog：每次任务写入 `workspace/logs/run_<run_id>.jsonl`
-
-## 状态
-
-- 当前仓库包含针对 Agent loop、CLI、工具系统、runlog 以及 OpenAI / Anthropic / Gemini / Qwen / vLLM provider 适配层的单元测试
-- 尚未提供针对真实上游 API 的集成 smoke test，因此正式发布前仍建议用目标模型做一次端到端验证
-
-## 文档
-
-详细使用说明和完整文档见 `docs/agentkit/`。
-
-## 从源码安装
-
-```bash
-uv sync
-uv run agentkit --help
-```
-
-## 从 PyPI 安装
-
-```bash
-pip install base-agentkit
-agentkit --help
-```
-
-安装后的导入路径和 CLI 名称保持不变：
-
-```python
-from agentkit import create_agent
-```
-
-## 配置示例
-
-### vLLM
-
-```yaml
-workspace:
-  root: "./vllm_workspace"
-
-provider:
-  kind: "vllm"
-  model: "glm-5"
-  openai_api_variant: "chat_completions"
-  conversation_mode: "auto"
-  base_url: "http://localhost:8000/v1"
-  api_key: "empty"
-  temperature: 0.8
-  timeout_s: 600
-  retries: 2
-  enable_thinking: true
-
-agent:
-  system_prompt: "You are a helpful agent. Use tools when needed."
-  budget:
-    max_steps: 200
-    time_budget_s: 1800
-    max_input_chars: 180000
-
-tools:
-  allowed:
-    - "view"
-    - "create_file"
-    - "str_replace"
-    - "word_count"
-
-runlog:
-  enabled: true
-  redact: true
-  max_text_chars: 20000
-```
-
-## CLI 运行
-
-```bash
-export OPENAI_API_KEY="your-key"
-uv run agentkit --config path/to/config.yaml run --task "列出当前 workspace 的文件"
-```
-
-## Python SDK
-
-```python
-from agentkit import create_agent
-
-agent = create_agent("path/to/config.yaml")
-report = agent.run("在 workspace 里新建 notes/todo.txt 并写入今天计划")
-print(report.final_output)
-```
-
-## 项目结构
-
-核心实现位于 `src/agentkit/`：
-
-- `config/`: 配置结构与加载
-- `workspace/`: 强隔离文件系统和目录布局
-- `llm/`: 统一抽象、provider base/factory 与四平台 adapter
-- `tools/`: 工具抽象、注册表与自动加载
-- `agent/`: budget、report、runtime、Agent loop
-- `runlog/`: 结构化事件、event sink 与 JSONL runlog
-- `cli/`: 命令行入口

base_agentkit-0.1.0/src/agentkit/tools/loader.py

@@ -1,81 +0,0 @@
-"""Automatic tool loading from the tool library directory."""
-
-from __future__ import annotations
-
-import importlib
-import inspect
-import pkgutil
-from typing import Any, Iterable
-
-from agentkit.errors import ToolError
-from agentkit.tools.base import Tool
-from agentkit.workspace.fs import WorkspaceFS
-
-TOOLS_LIBRARY_PACKAGE = "agentkit.tools.library"
-
-
-def load_tools_from_library(fs: WorkspaceFS) -> list[Tool]:
-    """Load all tools exposed by modules under ``agentkit.tools.library``.
-
-    Tool modules can expose tools via:
-    - ``build_tools(fs)`` (or ``build_tools()``)
-    - ``TOOLS`` module variable
-
-    Args:
-        fs: Workspace filesystem injected into callable tool factories.
-
-    Returns:
-        list[Tool]: Flattened list of tools from all library modules.
-    """
-    package = importlib.import_module(TOOLS_LIBRARY_PACKAGE)
-    package_path = getattr(package, "__path__", None)
-    if package_path is None:
-        return []
-
-    loaded: list[Tool] = []
-    for module_info in sorted(pkgutil.iter_modules(package_path), key=lambda m: m.name):
-        if module_info.name.startswith("_"):
-            continue
-        module_name = f"{TOOLS_LIBRARY_PACKAGE}.{module_info.name}"
-        module = importlib.import_module(module_name)
-        loaded.extend(_load_from_module(module, fs, module_name=module_name))
-    return loaded
-
-
-def _load_from_module(module: Any, fs: WorkspaceFS, *, module_name: str) -> list[Tool]:
-    """Extract tools from one library module."""
-    if hasattr(module, "build_tools"):
-        return _coerce_to_tools(getattr(module, "build_tools"), fs, module_name)
-    if hasattr(module, "TOOLS"):
-        return _coerce_to_tools(getattr(module, "TOOLS"), fs, module_name)
-    return []
-
-
-def _coerce_to_tools(candidate: Any, fs: WorkspaceFS, module_name: str) -> list[Tool]:
-    """Normalize supported tool declarations into ``list[Tool]``."""
-    if isinstance(candidate, Tool):
-        return [candidate]
-
-    if callable(candidate):
-        built: Any
-        try:
-            signature = inspect.signature(candidate)
-            if len(signature.parameters) == 0:
-                built = candidate()
-            else:
-                built = candidate(fs)
-        except ValueError:
-            built = candidate(fs)
-        return _coerce_to_tools(built, fs, module_name)
-
-    if isinstance(candidate, Iterable) and not isinstance(
-        candidate, (str, bytes, dict)
-    ):
-        tools = list(candidate)
-        if all(isinstance(item, Tool) for item in tools):
-            return tools
-
-    raise ToolError(
-        f"Module '{module_name}' must expose Tool, Iterable[Tool], build_tools(...), or TOOLS."
-    )
-