data/training_data/train.jsonl

{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`DatabaseService.get_session` 有什么功能？"}, {"role": "assistant", "content": "`DatabaseService.get_session` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/database.py`。\n**功能描述**：\nContext manager for database sessions.\n**函数签名**：\n```python\ndef get_session(self) -> Generator[Session, None, None]:\n```\n**参数**：\n- `self` (Any)\n\n**返回值**：`Generator[Session, None, None]`"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `_generate_readme` 的作用。"}, {"role": "assistant", "content": "`_generate_readme` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/commands/init.py`。\n**功能描述**：\nGenerate project README.\n**函数签名**：\n```python\ndef _generate_readme(project_path: Path, project_name: str) -> None:\n```\n**参数**：\n- `project_path` (Path)\n- `project_name` (str)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`InMemoryCache.delete` 方法在哪个文件里？"}, {"role": "assistant", "content": "`InMemoryCache.delete` 位于 `lib/laddr/src/laddr/core/cache.py`。"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `print_panel` 函数？"}, {"role": "assistant", "content": "`print_panel` 位于 `lib/laddr/src/laddr/cli/utils/logger.py`，使用方法如下：\n```python\nprint_panel(title=..., content=..., style=...)\n```\n**参数说明**：\n- `title`: str - Panel title\n- `content`: str\n- `style`: str\n\n**功能简述**：Print a styled panel. Args: title: Panel title content: Panel content style: Panel border style (default: cyan)..."}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`_get_span_type` 有什么功能？"}, {"role": "assistant", "content": "`_get_span_type` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/api/main.py`。\n**功能描述**：\nDetermine span type for UI rendering.\n**函数签名**：\n```python\ndef _get_span_type(event_type: str, payload: dict) -> str:\n```\n**参数**：\n- `event_type` (str)\n- `payload` (dict)\n\n**返回值**：`str`"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `ResponseMessage` 的作用。"}, {"role": "assistant", "content": "`ResponseMessage` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/core/message_bus.py`。\n**功能描述**：\nResponse from an agent after processing a task.\n**函数签名**：\n```python\nclass ResponseMessage:\n```"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `print_success` 的作用。"}, {"role": "assistant", "content": "`print_success` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/utils/logger.py`。\n**功能描述**：\nPrint a success message. Args: message: Main success message details: Optional additional details\n**函数签名**：\n```python\ndef print_success(message: str, details: str | None = None) -> None:\n```\n**参数**：\n- `message` (str): Main success message\n- `details` (str | None)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`InvalidConfigError.__init__` 方法在哪个文件里？"}, {"role": "assistant", "content": "`InvalidConfigError.__init__` 位于 `lib/laddr/src/laddr/cli/utils/errors.py`。"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `ToolRegistry.list` 的作用。"}, {"role": "assistant", "content": "`ToolRegistry.list` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/tooling.py`。\n**功能描述**：\nList all registered tools (excludes aliases).\n**函数签名**：\n```python\ndef list(self) -> list[Tool]:\n```\n**参数**：\n- `self` (Any)\n\n**返回值**：`list[Tool]`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`DatabaseService.get_token_usage` 方法在哪个文件里？"}, {"role": "assistant", "content": "`DatabaseService.get_token_usage` 位于 `lib/laddr/src/laddr/core/database.py`。"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`Agent._trace` 有什么功能？"}, {"role": "assistant", "content": "`Agent._trace` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/agent_runtime.py`。\n**功能描述**：\nAppend a trace if enabled and not masked.\n**函数签名**：\n```python\ndef _trace(self, job_id: str, agent_name: str, event_type: str, payload: dict) -> None:\n```\n**参数**：\n- `self` (Any)\n- `job_id` (str)\n- `agent_name` (str)\n- `event_type` (str)\n- `payload` (dict)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `LLMBackend` 是做什么的？"}, {"role": "assistant", "content": "`LLMBackend` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/core/config.py`。\n**功能描述**：\nProtocol for LLM backends.\n**函数签名**：\n```python\nclass LLMBackend(Protocol):\n```"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`init` 有什么功能？"}, {"role": "assistant", "content": "`init` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/commands/init.py`。\n**功能描述**：\nInitialize a new Laddr project. Creates project structure with: - Configuration files (laddr.yml, .env) - Docker setup (docker-compose.yml, Dockerfile) - Default researcher agent - Example tools and pipeline Users import from laddr package: from laddr import Agent, AgentRunner, run_agent, actor, tool Examples: laddr init myproject laddr init myproject --path /path/to/dir laddr init  # Interactive mode\n**函数签名**：\n```python\ndef init(project_name: str | None, path: str):\n```\n**参数**：\n- `project_name` (str | None)\n- `path` (str)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `DatabaseService.memory_put` 函数？"}, {"role": "assistant", "content": "`DatabaseService.memory_put` 位于 `lib/laddr/src/laddr/core/database.py`，使用方法如下：\n```python\nDatabaseService.memory_put(agent_name=..., key=..., value=..., job_id=...)\n```\n**参数说明**：\n- `agent_name`: str\n- `key`: str\n- `value`: Any\n- `job_id`: str | None\n\n**功能简述**：Store a memory entry...."}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `run_dev_alias` 是做什么的？"}, {"role": "assistant", "content": "`run_dev_alias` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/commands/run.py`。\n**功能描述**：\nAlias for 'laddr run dev'.\n**函数签名**：\n```python\ndef run_dev_alias():\n```\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `S3Storage.__init__` 函数？"}, {"role": "assistant", "content": "`S3Storage.__init__` 位于 `lib/laddr/src/laddr/core/storage.py`，使用方法如下：\n```python\nS3Storage.__init__(endpoint=..., access_key=..., secret_key=..., secure=..., region=...)\n```\n**参数说明**：\n- `endpoint`: str - S3 endpoint (e.g., \"s3.amazonaws.com\" or \"minio:9000\")\n- `access_key`: str\n- `secret_key`: str\n- `secure`: bool\n\n**功能简述**：Initialize S3-compatible storage. Args: endpoint: S3 endpoint (e.g., \"s3.amazonaws.com\" or \"minio:9000\") access_key: Access key (AWS Access Key ID or MinIO access key) secret_key: Secret key (AWS Secr..."}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `grok` 函数？"}, {"role": "assistant", "content": "`grok` 位于 `lib/laddr/src/laddr/llms.py`，使用方法如下：\n```python\ngrok(model=..., temperature=...)\n```\n**参数说明**：\n- `model`: str | None - Model name (default: grok-beta)\n- `temperature`: float | None\n\n**功能简述**：Create a xAI Grok LLM backend instance. Args: model: Model name (default: grok-beta) temperature: Generation temperature Example: llm = grok(model=\"grok-beta\", temperature=0.7)..."}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`ToolRegistry.list_all_names` 有什么功能？"}, {"role": "assistant", "content": "`ToolRegistry.list_all_names` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/tooling.py`。\n**功能描述**：\nList all names including aliases (for debugging).\n**函数签名**：\n```python\ndef list_all_names(self) -> list[str]:\n```\n**参数**：\n- `self` (Any)\n\n**返回值**：`list[str]`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`InMemoryCache.clear` 有什么功能？"}, {"role": "assistant", "content": "`InMemoryCache.clear` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/cache.py`。\n**功能描述**：\nClear all cache entries.\n**函数签名**：\n```python\ndef clear(self) -> None:\n```\n**参数**：\n- `self` (Any)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `InMemoryCache.__init__` 函数？"}, {"role": "assistant", "content": "`InMemoryCache.__init__` 位于 `lib/laddr/src/laddr/core/cache.py`，使用方法如下：\n**参数说明**："}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `cli` 是做什么的？"}, {"role": "assistant", "content": "`cli` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/main.py`。\n**功能描述**：\nLaddr - Transparent, Docker-native agent framework.\n**函数签名**：\n```python\ndef cli():\n```\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `BackendFactory.create_llm_backend` 是做什么的？"}, {"role": "assistant", "content": "`BackendFactory.create_llm_backend` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/config.py`。\n**功能描述**：\nCreate LLM backend based on config. If `override` is provided it takes precedence over the global `LaddrConfig.llm_backend`. `model_override` can be provided to select a different model for an agent.\n**函数签名**：\n```python\ndef create_llm_backend(self, override: str | None = None, model_override: str | None = None, agent_name: str | None = None) -> LLMBackend:\n```\n**参数**：\n- `self` (Any)\n- `override` (str | None)\n- `model_override` (str | None)\n- `agent_name` (str | None)\n\n**返回值**：`LLMBackend`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `CacheBackend.set` 函数？"}, {"role": "assistant", "content": "`CacheBackend.set` 位于 `lib/laddr/src/laddr/core/config.py`，使用方法如下：\n```python\nCacheBackend.set(key=..., value=..., ttl=...)\n```\n**参数说明**：\n- `key`: str\n- `value`: Any\n- `ttl`: int | None"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `DatabaseService.save_result` 函数？"}, {"role": "assistant", "content": "`DatabaseService.save_result` 位于 `lib/laddr/src/laddr/core/database.py`，使用方法如下：\n```python\nDatabaseService.save_result(job_id=..., outputs=..., status=...)\n```\n**参数说明**：\n- `job_id`: str\n- `outputs`: dict\n- `status`: str\n\n**功能简述**：Save job result...."}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `DatabaseService.save_prompt_result` 是做什么的？"}, {"role": "assistant", "content": "`DatabaseService.save_prompt_result` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/database.py`。\n**功能描述**：\nSave prompt execution result.\n**函数签名**：\n```python\ndef save_prompt_result(self, prompt_id: str, outputs: dict, status: str = \"completed\") -> None:\n```\n**参数**：\n- `self` (Any)\n- `prompt_id` (str)\n- `outputs` (dict)\n- `status` (str)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `ProjectConfigSchema.load_from_file` 函数？"}, {"role": "assistant", "content": "`ProjectConfigSchema.load_from_file` 位于 `lib/laddr/src/laddr/cli/utils/config.py`，使用方法如下：\n```python\nProjectConfigSchema.load_from_file(cls=..., path=...)\n```\n**参数说明**：\n- `cls`: Any\n- `path`: Path - Path to laddr.yml\n\n**功能简述**：Load project config from YAML file. Args: path: Path to laddr.yml Returns: Parsed project configuration Raises: InvalidConfigError: If config is invalid..."}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`replay_job` 函数在哪个文件里？"}, {"role": "assistant", "content": "`replay_job` 位于 `lib/laddr/src/laddr/cli/commands/run.py`。"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `AgentMemory.list` 函数？"}, {"role": "assistant", "content": "`AgentMemory.list` 位于 `lib/laddr/src/laddr/core/agent_runtime.py`，使用方法如下：\n**参数说明**：\n\n**功能简述**：List all memory entries...."}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `S3Storage._get_client` 函数？"}, {"role": "assistant", "content": "`S3Storage._get_client` 位于 `lib/laddr/src/laddr/core/storage.py`，使用方法如下：\n**参数说明**：\n\n**功能简述**：Get synchronous S3-compatible client...."}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `DatabaseService.get_session` 函数？"}, {"role": "assistant", "content": "`DatabaseService.get_session` 位于 `lib/laddr/src/laddr/core/database.py`，使用方法如下：\n**参数说明**：\n\n**功能简述**：Context manager for database sessions...."}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `TemplateRenderer.render_template` 的作用。"}, {"role": "assistant", "content": "`TemplateRenderer.render_template` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/cli/utils/templates.py`。\n**功能描述**：\nRender a template with context. Args: template_name: Template filename context: Template context variables Returns: Rendered template content Raises: FileGenerationError: If template rendering fails\n**函数签名**：\n```python\ndef render_template(self, template_name: str, context: dict[str, Any]) -> str:\n```\n**参数**：\n- `self` (Any)\n- `template_name` (str): Template filename\n- `context` (dict[str, Any])\n\n**返回值**：`str`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`add` 函数在哪个文件里？"}, {"role": "assistant", "content": "`add` 位于 `lib/laddr/src/laddr/cli/commands/add.py`。"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `scale` 函数？"}, {"role": "assistant", "content": "`scale` 位于 `lib/laddr/src/laddr/cli/commands/management.py`，使用方法如下：\n```python\nscale(agent_name=..., replicas=...)\n```\n**参数说明**：\n- `agent_name`: str\n- `replicas`: int\n\n**功能简述**：Scale an agent worker to N replicas. Examples: laddr scale researcher 3 laddr scale summarizer 0  # Stop all replicas..."}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `Tool.invoke` 函数？"}, {"role": "assistant", "content": "`Tool.invoke` 位于 `lib/laddr/src/laddr/core/tooling.py`，使用方法如下：\n**参数说明**：\n\n**功能简述**：Invoke the tool with validated inputs. Returns tool execution result...."}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `DatabaseService.append_trace` 函数？"}, {"role": "assistant", "content": "`DatabaseService.append_trace` 位于 `lib/laddr/src/laddr/core/database.py`，使用方法如下：\n```python\nDatabaseService.append_trace(job_id=..., agent_name=..., event_type=..., payload=...)\n```\n**参数说明**：\n- `job_id`: str\n- `agent_name`: str\n- `event_type`: str\n- `payload`: dict\n\n**功能简述**：Append a trace event...."}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `tool` 函数？"}, {"role": "assistant", "content": "`tool` 位于 `lib/laddr/src/laddr/core/tooling.py`，使用方法如下：\n```python\ntool(name=..., description=...)\n```\n**参数说明**：\n- `name`: str | None\n- `description`: str | None\n\n**功能简述**：Decorator to mark a function as an agent tool. Usage: @tool(name=\"web_search\", description=\"Search the web\") def search(query: str) -> dict: return {\"results\": [...]} Or with Pydantic input model: cla..."}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`AgentInfo` 类在哪个文件里？"}, {"role": "assistant", "content": "`AgentInfo` 位于 `lib/laddr/src/laddr/api/main.py`。"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `TemplateRenderer._pascal_case` 的作用。"}, {"role": "assistant", "content": "`TemplateRenderer._pascal_case` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/cli/utils/templates.py`。\n**功能描述**：\nConvert string to PascalCase.\n**函数签名**：\n```python\ndef _pascal_case(value: str) -> str:\n```\n**参数**：\n- `value` (str)\n\n**返回值**：`str`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `BackendFactory.__init__` 函数？"}, {"role": "assistant", "content": "`BackendFactory.__init__` 位于 `lib/laddr/src/laddr/core/config.py`，使用方法如下：\n```python\nBackendFactory.__init__(config=...)\n```\n**参数说明**：\n- `config`: LaddrConfig"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `list_prompts` 函数？"}, {"role": "assistant", "content": "`list_prompts` 位于 `lib/laddr/src/laddr/cli/commands/prompt.py`，使用方法如下：\n```python\nlist_prompts(limit=...)\n```\n**参数说明**：\n- `limit`: int\n\n**功能简述**：List recent prompt executions...."}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `ToolRegistry.has` 的作用。"}, {"role": "assistant", "content": "`ToolRegistry.has` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/tooling.py`。\n**功能描述**：\nCheck if a tool exists (checks both canonical names and aliases).\n**函数签名**：\n```python\ndef has(self, name: str) -> bool:\n```\n**参数**：\n- `self` (Any)\n- `name` (str)\n\n**返回值**：`bool`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`compose_up` 函数在哪个文件里？"}, {"role": "assistant", "content": "`compose_up` 位于 `lib/laddr/src/laddr/cli/utils/docker.py`。"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `HTTPLLM.__init__` 函数？"}, {"role": "assistant", "content": "`HTTPLLM.__init__` 位于 `lib/laddr/src/laddr/core/llm.py`，使用方法如下：\n```python\nHTTPLLM.__init__(endpoint=...)\n```\n**参数说明**：\n- `endpoint`: str"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `DatabaseService.list_jobs` 是做什么的？"}, {"role": "assistant", "content": "`DatabaseService.list_jobs` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/database.py`。\n**功能描述**：\nList recent jobs.\n**函数签名**：\n```python\ndef list_jobs(self, limit: int = 50) -> list[dict]:\n```\n**参数**：\n- `self` (Any)\n- `limit` (int)\n\n**返回值**：`list[dict]`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `AgentRunner.__init__` 函数？"}, {"role": "assistant", "content": "`AgentRunner.__init__` 位于 `lib/laddr/src/laddr/core/runtime_entry.py`，使用方法如下：\n```python\nAgentRunner.__init__(agent=..., env_config=...)\n```\n**参数说明**：\n- `agent`: Agent | None - Agent instance (created if None)\n- `env_config`: LaddrConfig | None\n\n**功能简述**：Initialize runner. Args: agent: Agent instance (created if None) env_config: Environment configuration..."}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `ToolRegistry.list_names` 函数？"}, {"role": "assistant", "content": "`ToolRegistry.list_names` 位于 `lib/laddr/src/laddr/core/tooling.py`，使用方法如下：\n**参数说明**：\n\n**功能简述**：List all canonical tool names (excludes aliases)...."}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`DatabaseService.get_token_usage` 有什么功能？"}, {"role": "assistant", "content": "`DatabaseService.get_token_usage` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/database.py`。\n**功能描述**：\nAggregate token usage for a job from llm_usage traces.\n**函数签名**：\n```python\ndef get_token_usage(self, job_id: str) -> dict:\n```\n**参数**：\n- `self` (Any)\n- `job_id` (str)\n\n**返回值**：`dict`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`ToolRegistry` 有什么功能？"}, {"role": "assistant", "content": "`ToolRegistry` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/core/tooling.py`。\n**功能描述**：\nRegistry for managing available tools. Supports registration, lookup, and listing of tools.\n**函数签名**：\n```python\nclass ToolRegistry:\n```"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `DatabaseBackend.get_result` 函数？"}, {"role": "assistant", "content": "`DatabaseBackend.get_result` 位于 `lib/laddr/src/laddr/core/config.py`，使用方法如下：\n```python\nDatabaseBackend.get_result(job_id=...)\n```\n**参数说明**：\n- `job_id`: str"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`AgentInfo` 有什么功能？"}, {"role": "assistant", "content": "`AgentInfo` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/api/main.py`。\n**功能描述**：\nAgent information.\n**函数签名**：\n```python\nclass AgentInfo(BaseModel):\n```"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `clear_tool_overrides` 的作用。"}, {"role": "assistant", "content": "`clear_tool_overrides` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/core/system_tools.py`。\n**功能描述**：\nClear all tool overrides. Useful for testing.\n**函数签名**：\n```python\ndef clear_tool_overrides():\n```\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `ParallelDelegationTool.__init__` 函数？"}, {"role": "assistant", "content": "`ParallelDelegationTool.__init__` 位于 `lib/laddr/src/laddr/core/system_tools.py`，使用方法如下：\n```python\nParallelDelegationTool.__init__(message_bus=..., artifact_storage=..., agent=...)\n```\n**参数说明**：\n- `message_bus`: Any - Message queue backend for inter-agent communication\n- `artifact_storage`: Any\n- `agent`: Any\n\n**功能简述**：Initialize parallel delegation tool. Args: message_bus: Message queue backend for inter-agent communication artifact_storage: Optional storage backend for large payloads agent: Optional agent instance..."}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `DatabaseService.create_job` 函数？"}, {"role": "assistant", "content": "`DatabaseService.create_job` 位于 `lib/laddr/src/laddr/core/database.py`，使用方法如下：\n```python\nDatabaseService.create_job(job_id=..., pipeline=..., inputs=...)\n```\n**参数说明**：\n- `job_id`: str | None\n- `pipeline`: str\n- `inputs`: dict\n\n**功能简述**：Create a new job record, or reuse existing if job_id already exists (for sequential chains)...."}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `PromptExecution` 是做什么的？"}, {"role": "assistant", "content": "`PromptExecution` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/core/database.py`。\n**功能描述**：\nPrompt execution record (new terminology for pipeline/job).\n**函数签名**：\n```python\nclass PromptExecution(Base):\n```"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`list_prompts` 函数在哪个文件里？"}, {"role": "assistant", "content": "`list_prompts` 位于 `lib/laddr/src/laddr/cli/commands/prompt.py`。"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `stop` 函数？"}, {"role": "assistant", "content": "`stop` 位于 `lib/laddr/src/laddr/cli/commands/management.py`，使用方法如下：\n```python\nstop(volumes=...)\n```\n**参数说明**：\n- `volumes`: bool\n\n**功能简述**：Stop all Laddr services. Examples: laddr stop laddr stop --volumes  # Also remove data volumes..."}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`AgentMemory.get` 方法在哪个文件里？"}, {"role": "assistant", "content": "`AgentMemory.get` 位于 `lib/laddr/src/laddr/core/agent_runtime.py`。"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`run_local` 函数在哪个文件里？"}, {"role": "assistant", "content": "`run_local` 位于 `lib/laddr/src/laddr/cli/main.py`。"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`Memory` 类在哪个文件里？"}, {"role": "assistant", "content": "`Memory` 位于 `lib/laddr/src/laddr/core/database.py`。"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`S3Storage` 有什么功能？"}, {"role": "assistant", "content": "`S3Storage` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/core/storage.py`。\n**功能描述**：\nS3-compatible storage backend for AWS S3 and MinIO. This class uses the minio Python package which is fully compatible with: - AWS S3 (cloud) - MinIO (self-hosted) - Any S3-compatible storage service For AWS S3: endpoint: \"s3.amazonaws.com\" or \"s3.<region>.amazonaws.com\" access_key: AWS Access Key ID secret_key: AWS Secret Access Key secure: True (use HTTPS) For MinIO: endpoint: \"localhost:9000\" or \"minio:9000\" access_key: MinIO access key (default: minioadmin) secret_key: MinIO secret key secure: False (or True for HTTPS)\n**函数签名**：\n```python\nclass S3Storage:\n```"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `_generate_core_modules` 是做什么的？"}, {"role": "assistant", "content": "`_generate_core_modules` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/commands/init.py`。\n**功能描述**：\nV3.0: Users import from laddr package, no need to generate core files. This function is kept for backward compatibility but does nothing. Users should use: from laddr import Agent, AgentRunner, run_agent\n**函数签名**：\n```python\ndef _generate_core_modules(project_path: Path) -> None:\n```\n**参数**：\n- `project_path` (Path)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `GrokLLM` 的作用。"}, {"role": "assistant", "content": "`GrokLLM` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/core/llm.py`。\n**功能描述**：\nxAI Grok LLM backend - uses native HTTP API.\n**函数签名**：\n```python\nclass GrokLLM:\n```"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `TemplateRenderer._snake_case` 函数？"}, {"role": "assistant", "content": "`TemplateRenderer._snake_case` 位于 `lib/laddr/src/laddr/cli/utils/templates.py`，使用方法如下：\n```python\nTemplateRenderer._snake_case(value=...)\n```\n**参数说明**：\n- `value`: str\n\n**功能简述**：Convert string to snake_case...."}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`build_image` 函数在哪个文件里？"}, {"role": "assistant", "content": "`build_image` 位于 `lib/laddr/src/laddr/cli/utils/docker.py`。"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `DatabaseService.get_prompt_result` 函数？"}, {"role": "assistant", "content": "`DatabaseService.get_prompt_result` 位于 `lib/laddr/src/laddr/core/database.py`，使用方法如下：\n```python\nDatabaseService.get_prompt_result(prompt_id=...)\n```\n**参数说明**：\n- `prompt_id`: str\n\n**功能简述**：Get prompt execution result...."}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`infra` 有什么功能？"}, {"role": "assistant", "content": "`infra` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/commands/infra.py`。\n**功能描述**：\nShow infrastructure configuration and status.\n**函数签名**：\n```python\ndef infra(show_config: bool):\n```\n**参数**：\n- `show_config` (bool)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`stop` 函数在哪个文件里？"}, {"role": "assistant", "content": "`stop` 位于 `lib/laddr/src/laddr/cli/commands/management.py`。"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `Job` 是做什么的？"}, {"role": "assistant", "content": "`Job` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/core/database.py`。\n**功能描述**：\nJob execution record (legacy terminology).\n**函数签名**：\n```python\nclass Job(Base):\n```"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`Tool` 有什么功能？"}, {"role": "assistant", "content": "`Tool` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/core/tooling.py`。\n**功能描述**：\nTool metadata and callable. Represents a single tool that can be invoked by agents.\n**函数签名**：\n```python\nclass Tool:\n```"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `DatabaseService.create_tables` 函数？"}, {"role": "assistant", "content": "`DatabaseService.create_tables` 位于 `lib/laddr/src/laddr/core/database.py`，使用方法如下：\n**参数说明**：\n\n**功能简述**：Create all database tables if they don't exist...."}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `main` 是做什么的？"}, {"role": "assistant", "content": "`main` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/main.py`。\n**功能描述**：\nMain entry point with error handling.\n**函数签名**：\n```python\ndef main():\n```\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `WorkerRunner.__init__` 函数？"}, {"role": "assistant", "content": "`WorkerRunner.__init__` 位于 `lib/laddr/src/laddr/core/runtime_entry.py`，使用方法如下：\n```python\nWorkerRunner.__init__(agent=..., database_url=..., redis_url=..., storage_endpoint=..., storage_access_key=...)\n```\n**参数说明**：\n- `agent`: Agent\n- `database_url`: str | None\n- `redis_url`: str | None\n- `storage_endpoint`: str | None"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `create_system_tools` 函数？"}, {"role": "assistant", "content": "`create_system_tools` 位于 `lib/laddr/src/laddr/core/system_tools.py`，使用方法如下：\n```python\ncreate_system_tools(message_bus=..., storage_backend=..., agent=...)\n```\n**参数说明**：\n- `message_bus`: Any - Message queue backend\n- `storage_backend`: Any\n- `agent`: Any\n\n**功能简述**：Create system tools for task delegation and artifact management. This function checks for user-provided overrides before registering the default implementations. Users can use @override_system_tool de..."}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`ProjectDetails` 类在哪个文件里？"}, {"role": "assistant", "content": "`ProjectDetails` 位于 `lib/laddr/src/laddr/cli/utils/config.py`。"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `DatabaseService.update_prompt_status` 是做什么的？"}, {"role": "assistant", "content": "`DatabaseService.update_prompt_status` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/database.py`。\n**功能描述**：\nUpdate prompt execution status only; set completed_at for terminal states.\n**函数签名**：\n```python\ndef update_prompt_status(self, prompt_id: str, status: str) -> None:\n```\n**参数**：\n- `self` (Any)\n- `prompt_id` (str)\n- `status` (str)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `GroqLLM` 是做什么的？"}, {"role": "assistant", "content": "`GroqLLM` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/core/llm.py`。\n**功能描述**：\nGroq LLM backend (ultra-fast inference).\n**函数签名**：\n```python\nclass GroqLLM:\n```"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`AgentChatRequest` 类在哪个文件里？"}, {"role": "assistant", "content": "`AgentChatRequest` 位于 `lib/laddr/src/laddr/api/main.py`。"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `Trace` 是做什么的？"}, {"role": "assistant", "content": "`Trace` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/core/database.py`。\n**功能描述**：\nTrace event for observability with hierarchical span support.\n**函数签名**：\n```python\nclass Trace(Base):\n```"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`InMemoryCache.__init__` 方法在哪个文件里？"}, {"role": "assistant", "content": "`InMemoryCache.__init__` 位于 `lib/laddr/src/laddr/core/cache.py`。"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `AgentRunner.replay` 是做什么的？"}, {"role": "assistant", "content": "`AgentRunner.replay` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/runtime_entry.py`。\n**功能描述**：\nReplay a previous job. Args: job_id: Job ID to replay reexecute: If True, re-execute the job; if False, return stored result Returns: Job result\n**函数签名**：\n```python\ndef replay(\nself,\njob_id: str,\nreexecute: bool = False\n) -> dict:\n```\n**参数**：\n- `self` (Any)\n- `job_id` (str): Job ID to replay\n- `reexecute` (bool)\n\n**返回值**：`dict`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`Agent` 有什么功能？"}, {"role": "assistant", "content": "`Agent` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/__init__.py`。\n**功能描述**：\nFactory for user-friendly Agent(...) syntax. Creates a CoreAgent instance under the hood using AgentConfig and LaddrConfig. Unrecognized parameters like max_retries/timeout are currently accepted for forward-compatibility but not used directly.\n**函数签名**：\n```python\ndef Agent(\n*,\nname: str,\nrole: str,\ngoal: str,\n```\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `KafkaBus.__init__` 函数？"}, {"role": "assistant", "content": "`KafkaBus.__init__` 位于 `lib/laddr/src/laddr/core/message_bus.py`，使用方法如下：\n```python\nKafkaBus.__init__(bootstrap_servers=...)\n```\n**参数说明**：\n- `bootstrap_servers`: str"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `decorator` 函数？"}, {"role": "assistant", "content": "`decorator` 位于 `lib/laddr/src/laddr/core/tooling.py`，使用方法如下：\n```python\ndecorator(func=...)\n```\n**参数说明**：\n- `func`: Callable"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `GrokLLM.__init__` 函数？"}, {"role": "assistant", "content": "`GrokLLM.__init__` 位于 `lib/laddr/src/laddr/core/llm.py`，使用方法如下：\n```python\nGrokLLM.__init__(api_key=..., model=...)\n```\n**参数说明**：\n- `api_key`: str | None\n- `model`: str | None"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `infra` 函数？"}, {"role": "assistant", "content": "`infra` 位于 `lib/laddr/src/laddr/cli/commands/infra.py`，使用方法如下：\n```python\ninfra(show_config=...)\n```\n**参数说明**：\n- `show_config`: bool\n\n**功能简述**：Show infrastructure configuration and status...."}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `add_agent` 函数？"}, {"role": "assistant", "content": "`add_agent` 位于 `lib/laddr/src/laddr/cli/commands/add.py`，使用方法如下：\n```python\nadd_agent(agent_name=..., role=..., goal=..., backstory=..., llm_provider=...)\n```\n**参数说明**：\n- `agent_name`: str\n- `role`: str | None\n- `goal`: str | None\n- `backstory`: str | None\n- `llm_provider`: str\n\n**功能简述**：Add a new agent to the project. Examples: laddr add agent summarizer laddr add agent analyst --role \"Data Analyst\" --goal \"Analyze data\"..."}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `DatabaseBackend.list_agents` 函数？"}, {"role": "assistant", "content": "`DatabaseBackend.list_agents` 位于 `lib/laddr/src/laddr/core/config.py`，使用方法如下：\n**参数说明**："}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `RedisCache` 是做什么的？"}, {"role": "assistant", "content": "`RedisCache` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/core/cache.py`。\n**功能描述**：\nRedis-based cache for production. Uses Redis with TTL support.\n**函数签名**：\n```python\nclass RedisCache:\n```"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`_print_management_commands` 有什么功能？"}, {"role": "assistant", "content": "`_print_management_commands` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/commands/run.py`。\n**功能描述**：\nPrint management command help in minimalistic style.\n**函数签名**：\n```python\ndef _print_management_commands() -> None:\n```\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`ServiceNotReadyError.__init__` 方法在哪个文件里？"}, {"role": "assistant", "content": "`ServiceNotReadyError.__init__` 位于 `lib/laddr/src/laddr/cli/utils/errors.py`。"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`_LLMWithDefaults` 类在哪个文件里？"}, {"role": "assistant", "content": "`_LLMWithDefaults` 位于 `lib/laddr/src/laddr/llms.py`。"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `DatabaseBackend` 的作用。"}, {"role": "assistant", "content": "`DatabaseBackend` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/core/config.py`。\n**功能描述**：\nProtocol for database backends.\n**函数签名**：\n```python\nclass DatabaseBackend(Protocol):\n```"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `Agent.plan` 函数？"}, {"role": "assistant", "content": "`Agent.plan` 位于 `lib/laddr/src/laddr/core/agent_runtime.py`，使用方法如下：\n```python\nAgent.plan(task=...)\n```\n**参数说明**：\n- `task`: dict - Task inputs\n\n**功能简述**：Create execution plan for a task. Default implementation: simple single-step plan. Subclasses should override for custom planning logic. Args: task: Task inputs Returns: List of steps, where each step..."}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`run_local` 有什么功能？"}, {"role": "assistant", "content": "`run_local` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/main.py`。\n**功能描述**：\nRun an agent once locally using in-memory components (no Redis/DB).\n**函数签名**：\n```python\ndef run_local(agent: str, input_json: str):\n```\n**参数**：\n- `agent` (str)\n- `input_json` (str)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`infra` 函数在哪个文件里？"}, {"role": "assistant", "content": "`infra` 位于 `lib/laddr/src/laddr/cli/commands/infra.py`。"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `Agent._build_autonomous_user_prompt` 的作用。"}, {"role": "assistant", "content": "`Agent._build_autonomous_user_prompt` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/agent_runtime.py`。\n**功能描述**：\nBuild user prompt with task and history.\n**函数签名**：\n```python\ndef _build_autonomous_user_prompt(\nself,\ntask_description: str,\nhistory: list[dict],\niteration: int\n```\n**参数**：\n- `self` (Any)\n- `task_description` (str)\n- `history` (list[dict])\n- `iteration` (int)\n\n**返回值**：`str`"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `ProjectNotFoundError` 的作用。"}, {"role": "assistant", "content": "`ProjectNotFoundError` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/cli/utils/errors.py`。\n**功能描述**：\nRaised when not in an Laddr project directory.\n**函数签名**：\n```python\nclass ProjectNotFoundError(LaddrError):\n```"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `TaskDelegationTool.__init__` 函数？"}, {"role": "assistant", "content": "`TaskDelegationTool.__init__` 位于 `lib/laddr/src/laddr/core/system_tools.py`，使用方法如下：\n```python\nTaskDelegationTool.__init__(message_bus=..., artifact_storage=..., agent=...)\n```\n**参数说明**：\n- `message_bus`: Any - Message queue backend for inter-agent communication\n- `artifact_storage`: Any\n- `agent`: Any\n\n**功能简述**：Initialize task delegation tool. Args: message_bus: Message queue backend for inter-agent communication artifact_storage: Optional storage backend for large payloads agent: Optional agent instance for..."}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`wait_for_service` 有什么功能？"}, {"role": "assistant", "content": "`wait_for_service` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/utils/docker.py`。\n**功能描述**：\nWait for a service to be healthy. Args: service: Service name timeout: Maximum seconds to wait check_interval: Seconds between checks Returns: True if service is healthy, False otherwise\n**函数签名**：\n```python\ndef wait_for_service(\nservice: str,\ntimeout: int = 30,\ncheck_interval: int = 2,\n) -> bool:\n```\n**参数**：\n- `service` (str): Service name\n- `timeout` (int)\n- `check_interval` (int)\n\n**返回值**：`bool`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `run_agent_cmd` 函数？"}, {"role": "assistant", "content": "`run_agent_cmd` 位于 `lib/laddr/src/laddr/cli/commands/run.py`，使用方法如下：\n```python\nrun_agent_cmd(agent_name=..., inputs_json=...)\n```\n**参数说明**：\n- `agent_name`: str\n- `inputs_json`: str\n\n**功能简述**：Run a single agent locally using AgentRunner...."}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `DatabaseService.create_prompt` 函数？"}, {"role": "assistant", "content": "`DatabaseService.create_prompt` 位于 `lib/laddr/src/laddr/core/database.py`，使用方法如下：\n```python\nDatabaseService.create_prompt(prompt_id=..., prompt_name=..., inputs=...)\n```\n**参数说明**：\n- `prompt_id`: str | None\n- `prompt_name`: str\n- `inputs`: dict\n\n**功能简述**：Create a new prompt execution record...."}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `InMemoryCache.set` 函数？"}, {"role": "assistant", "content": "`InMemoryCache.set` 位于 `lib/laddr/src/laddr/core/cache.py`，使用方法如下：\n```python\nInMemoryCache.set(key=..., value=..., ttl=...)\n```\n**参数说明**：\n- `key`: str\n- `value`: Any\n- `ttl`: int | None\n\n**功能简述**：Set value in cache with optional TTL (seconds)...."}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `CacheBackend.get` 函数？"}, {"role": "assistant", "content": "`CacheBackend.get` 位于 `lib/laddr/src/laddr/core/config.py`，使用方法如下：\n```python\nCacheBackend.get(key=...)\n```\n**参数说明**：\n- `key`: str"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `discover_tools` 是做什么的？"}, {"role": "assistant", "content": "`discover_tools` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/core/tooling.py`。\n**功能描述**：\nAuto-discover tools for an agent from agents.<agent_name>.tools package. Scans for: 1. Functions decorated with @tool 2. Functions named 'run' (fallback) Args: agent_name: Name of the agent (e.g., \"researcher\") Returns: ToolRegistry with discovered tools\n**函数签名**：\n```python\ndef discover_tools(agent_name: str) -> ToolRegistry:\n```\n**参数**：\n- `agent_name` (str): Name of the agent (e.g., \"researcher\")\n\n**返回值**：`ToolRegistry`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`AgentRunner._stop_inline_workers` 方法在哪个文件里？"}, {"role": "assistant", "content": "`AgentRunner._stop_inline_workers` 位于 `lib/laddr/src/laddr/core/runtime_entry.py`。"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `run_local` 函数？"}, {"role": "assistant", "content": "`run_local` 位于 `lib/laddr/src/laddr/cli/main.py`，使用方法如下：\n```python\nrun_local(agent=..., input_json=...)\n```\n**参数说明**：\n- `agent`: str\n- `input_json`: str\n\n**功能简述**：Run an agent once locally using in-memory components (no Redis/DB)...."}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `InMemoryCache.get` 函数？"}, {"role": "assistant", "content": "`InMemoryCache.get` 位于 `lib/laddr/src/laddr/core/cache.py`，使用方法如下：\n```python\nInMemoryCache.get(key=...)\n```\n**参数说明**：\n- `key`: str\n\n**功能简述**：Get value from cache...."}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `print_success` 函数？"}, {"role": "assistant", "content": "`print_success` 位于 `lib/laddr/src/laddr/cli/utils/logger.py`，使用方法如下：\n```python\nprint_success(message=..., details=...)\n```\n**参数说明**：\n- `message`: str - Main success message\n- `details`: str | None\n\n**功能简述**：Print a success message. Args: message: Main success message details: Optional additional details..."}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `DatabaseService` 是做什么的？"}, {"role": "assistant", "content": "`DatabaseService` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/core/database.py`。\n**功能描述**：\nHigh-level database API. Provides methods for job management, tracing, memory, and agent registry. Supports both Postgres and SQLite.\n**函数签名**：\n```python\nclass DatabaseService:\n```"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `FileGenerationError` 是做什么的？"}, {"role": "assistant", "content": "`FileGenerationError` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/cli/utils/errors.py`。\n**功能描述**：\nRaised when file generation fails.\n**函数签名**：\n```python\nclass FileGenerationError(LaddrError):\n```"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `NestedProjectError` 的作用。"}, {"role": "assistant", "content": "`NestedProjectError` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/cli/utils/errors.py`。\n**功能描述**：\nRaised when trying to create a nested project.\n**函数签名**：\n```python\nclass NestedProjectError(LaddrError):\n```"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`_create_tool_file` 函数在哪个文件里？"}, {"role": "assistant", "content": "`_create_tool_file` 位于 `lib/laddr/src/laddr/cli/commands/add.py`。"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `InMemoryCache.get` 是做什么的？"}, {"role": "assistant", "content": "`InMemoryCache.get` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/cache.py`。\n**功能描述**：\nGet value from cache.\n**函数签名**：\n```python\ndef get(self, key: str) -> Any:\n```\n**参数**：\n- `self` (Any)\n- `key` (str)\n\n**返回值**：`Any`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`add_worker_to_compose` 有什么功能？"}, {"role": "assistant", "content": "`add_worker_to_compose` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/utils/docker.py`。\n**功能描述**：\nAdd worker service to docker-compose.yml. Args: project_path: Path to project root agent_name: Name of the agent\n**函数签名**：\n```python\ndef add_worker_to_compose(project_path: Path, agent_name: str) -> None:\n```\n**参数**：\n- `project_path` (Path): Path to project root\n- `agent_name` (str)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `InMemoryStorage.__init__` 函数？"}, {"role": "assistant", "content": "`InMemoryStorage.__init__` 位于 `lib/laddr/src/laddr/core/storage.py`，使用方法如下：\n**参数说明**：\n\n**功能简述**：Initialize in-memory storage...."}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`HTTPLLM.__init__` 方法在哪个文件里？"}, {"role": "assistant", "content": "`HTTPLLM.__init__` 位于 `lib/laddr/src/laddr/core/llm.py`。"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `LaddrConfig` 是做什么的？"}, {"role": "assistant", "content": "`LaddrConfig` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/core/config.py`。\n**功能描述**：\nEnvironment-based configuration for Laddr runtime. Supports pluggable backends for all infrastructure: - queue_backend: \"redis\" (default) | \"memory\" - db_backend: \"postgres\" (default) | \"sqlite\" - llm_backend: \"noop\" (default) | \"openai\" | \"anthropic\" | \"gemini\" - cache_backend: \"inmemory\" (default) | \"redis\"\n**函数签名**：\n```python\nclass LaddrConfig(BaseSettings):\n```"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`print_header` 函数在哪个文件里？"}, {"role": "assistant", "content": "`print_header` 位于 `lib/laddr/src/laddr/cli/utils/logger.py`。"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `MCPToolRegistry` 的作用。"}, {"role": "assistant", "content": "`MCPToolRegistry` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/core/mcp_client.py`。\n**功能描述**：\nPlaceholder - MCP feature disabled for this release.\n**函数签名**：\n```python\nclass MCPToolRegistry:\n```"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `TaskMessage.from_dict` 函数？"}, {"role": "assistant", "content": "`TaskMessage.from_dict` 位于 `lib/laddr/src/laddr/core/message_bus.py`，使用方法如下：\n```python\nTaskMessage.from_dict(cls=..., data=...)\n```\n**参数说明**：\n- `cls`: Any\n- `data`: dict"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`compose_ps` 函数在哪个文件里？"}, {"role": "assistant", "content": "`compose_ps` 位于 `lib/laddr/src/laddr/cli/utils/docker.py`。"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `get_logger` 函数？"}, {"role": "assistant", "content": "`get_logger` 位于 `lib/laddr/src/laddr/cli/utils/logger.py`，使用方法如下：\n```python\nget_logger(name=..., level=...)\n```\n**参数说明**：\n- `name`: str - Logger name (usually __name__)\n- `level`: int\n\n**功能简述**：Get a configured logger with rich handler. Args: name: Logger name (usually __name__) level: Log level (default: INFO) Returns: Configured logger instance..."}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `Agent._format_history_for_synthesis` 函数？"}, {"role": "assistant", "content": "`Agent._format_history_for_synthesis` 位于 `lib/laddr/src/laddr/core/agent_runtime.py`，使用方法如下：\n```python\nAgent._format_history_for_synthesis(history=...)\n```\n**参数说明**：\n- `history`: list[dict]\n\n**功能简述**：Format execution history for final answer synthesis...."}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `RedisBus.__init__` 函数？"}, {"role": "assistant", "content": "`RedisBus.__init__` 位于 `lib/laddr/src/laddr/core/message_bus.py`，使用方法如下：\n```python\nRedisBus.__init__(redis_url=...)\n```\n**参数说明**：\n- `redis_url`: str"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `ReplayJobRequest` 的作用。"}, {"role": "assistant", "content": "`ReplayJobRequest` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/api/main.py`。\n**功能描述**：\nRequest to replay a job.\n**函数签名**：\n```python\nclass ReplayJobRequest(BaseModel):\n```"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `ToolRegistry.has` 函数？"}, {"role": "assistant", "content": "`ToolRegistry.has` 位于 `lib/laddr/src/laddr/core/tooling.py`，使用方法如下：\n```python\nToolRegistry.has(name=...)\n```\n**参数说明**：\n- `name`: str\n\n**功能简述**：Check if a tool exists (checks both canonical names and aliases)...."}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`scale` 函数在哪个文件里？"}, {"role": "assistant", "content": "`scale` 位于 `lib/laddr/src/laddr/cli/commands/management.py`。"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `KafkaBus` 的作用。"}, {"role": "assistant", "content": "`KafkaBus` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/core/message_bus.py`。\n**功能描述**：\nKafka-based message bus (experimental / enterprise option). Uses topics per agent: laddr.tasks.<agent_name> Responses published to: laddr.responses Agent registry is memory-only in this minimal implementation.\n**函数签名**：\n```python\nclass KafkaBus:\n```"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `DatabaseService.update_prompt_status` 函数？"}, {"role": "assistant", "content": "`DatabaseService.update_prompt_status` 位于 `lib/laddr/src/laddr/core/database.py`，使用方法如下：\n```python\nDatabaseService.update_prompt_status(prompt_id=..., status=...)\n```\n**参数说明**：\n- `prompt_id`: str\n- `status`: str\n\n**功能简述**：Update prompt execution status only; set completed_at for terminal states...."}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `DatabaseService.get_result` 的作用。"}, {"role": "assistant", "content": "`DatabaseService.get_result` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/database.py`。\n**功能描述**：\nGet job result.\n**函数签名**：\n```python\ndef get_result(self, job_id: str) -> dict | None:\n```\n**参数**：\n- `self` (Any)\n- `job_id` (str)\n\n**返回值**：`dict | None`"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `add_agent` 是做什么的？"}, {"role": "assistant", "content": "`add_agent` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/commands/add.py`。\n**功能描述**：\nAdd a new agent to the project. Examples: laddr add agent summarizer laddr add agent analyst --role \"Data Analyst\" --goal \"Analyze data\"\n**函数签名**：\n```python\ndef add_agent(\nagent_name: str,\nrole: str | None,\ngoal: str | None,\nbackstory: str | None,\n```\n**参数**：\n- `agent_name` (str)\n- `role` (str | None)\n- `goal` (str | None)\n- `backstory` (str | None)\n- `llm_provider` (str)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`grok` 有什么功能？"}, {"role": "assistant", "content": "`grok` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/llms.py`。\n**功能描述**：\nCreate a xAI Grok LLM backend instance. Args: model: Model name (default: grok-beta) temperature: Generation temperature Example: llm = grok(model=\"grok-beta\", temperature=0.7)\n**函数签名**：\n```python\ndef grok(model: str | None = None, temperature: float | None = None) -> _LLMWithDefaults:\n```\n**参数**：\n- `model` (str | None): Model name (default: grok-beta)\n- `temperature` (float | None)\n\n**返回值**：`_LLMWithDefaults`"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `add_tool` 的作用。"}, {"role": "assistant", "content": "`add_tool` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/commands/add.py`。\n**功能描述**：\nAdd a new tool to an agent. Examples: laddr add tool calculator laddr add tool scraper --agent researcher\n**函数签名**：\n```python\ndef add_tool(\ntool_name: str,\nagent: str | None,\ndescription: str | None,\n):\n```\n**参数**：\n- `tool_name` (str)\n- `agent` (str | None)\n- `description` (str | None)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `DatabaseBackend.memory_put` 函数？"}, {"role": "assistant", "content": "`DatabaseBackend.memory_put` 位于 `lib/laddr/src/laddr/core/config.py`，使用方法如下：\n```python\nDatabaseBackend.memory_put(agent_name=..., key=..., value=..., job_id=...)\n```\n**参数说明**：\n- `agent_name`: str\n- `key`: str\n- `value`: Any\n- `job_id`: str | None"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`S3Storage.__init__` 方法在哪个文件里？"}, {"role": "assistant", "content": "`S3Storage.__init__` 位于 `lib/laddr/src/laddr/core/storage.py`。"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`TemplateRenderer._snake_case` 有什么功能？"}, {"role": "assistant", "content": "`TemplateRenderer._snake_case` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/cli/utils/templates.py`。\n**功能描述**：\nConvert string to snake_case.\n**函数签名**：\n```python\ndef _snake_case(value: str) -> str:\n```\n**参数**：\n- `value` (str)\n\n**返回值**：`str`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `InMemoryCache.clear` 函数？"}, {"role": "assistant", "content": "`InMemoryCache.clear` 位于 `lib/laddr/src/laddr/core/cache.py`，使用方法如下：\n**参数说明**：\n\n**功能简述**：Clear all cache entries...."}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `replay_job` 的作用。"}, {"role": "assistant", "content": "`replay_job` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/commands/run.py`。\n**功能描述**：\nReplay a previous job by job ID. Examples: laddr run replay abc123-456-def laddr run replay abc123-456-def --reexecute\n**函数签名**：\n```python\ndef replay_job(job_id: str, reexecute: bool):\n```\n**参数**：\n- `job_id` (str)\n- `reexecute` (bool)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `Agent._build_autonomous_system_prompt` 是做什么的？"}, {"role": "assistant", "content": "`Agent._build_autonomous_system_prompt` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/agent_runtime.py`。\n**功能描述**：\nBuild system prompt for autonomous agent.\n**函数签名**：\n```python\ndef _build_autonomous_system_prompt(\nself,\navailable_tools: list[str],\navailable_agents: list[dict],\ncan_delegate: bool,\n```\n**参数**：\n- `self` (Any)\n- `available_tools` (list[str])\n- `available_agents` (list[dict])\n- `can_delegate` (bool)\n\n**返回值**：`str`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `GeminiLLM.__init__` 函数？"}, {"role": "assistant", "content": "`GeminiLLM.__init__` 位于 `lib/laddr/src/laddr/core/llm.py`，使用方法如下：\n```python\nGeminiLLM.__init__(api_key=..., model=...)\n```\n**参数说明**：\n- `api_key`: str | None\n- `model`: str | None"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `write_file` 是做什么的？"}, {"role": "assistant", "content": "`write_file` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/utils/templates.py`。\n**功能描述**：\nWrite content to a file. Args: path: File path content: File content create_dirs: Create parent directories if needed (default: True) Raises: FileGenerationError: If write fails\n**函数签名**：\n```python\ndef write_file(path: Path, content: str, create_dirs: bool = True) -> None:\n```\n**参数**：\n- `path` (Path): File path\n- `content` (str)\n- `create_dirs` (bool)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `BackendFactory.create_storage_backend` 函数？"}, {"role": "assistant", "content": "`BackendFactory.create_storage_backend` 位于 `lib/laddr/src/laddr/core/config.py`，使用方法如下：\n**参数说明**：\n\n**功能简述**：Create S3-compatible storage backend (AWS S3, MinIO, or compatible). Supports backward compatibility with old minio_* field names...."}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`TemplateRenderer.render_to_file` 有什么功能？"}, {"role": "assistant", "content": "`TemplateRenderer.render_to_file` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/cli/utils/templates.py`。\n**功能描述**：\nRender a template and write to file. Args: template_name: Template filename output_path: Output file path context: Template context variables create_dirs: Create parent directories if needed (default: True) Raises: FileGenerationError: If rendering or writing fails\n**函数签名**：\n```python\ndef render_to_file(\nself,\ntemplate_name: str,\noutput_path: Path,\ncontext: dict[str, Any],\n```\n**参数**：\n- `self` (Any)\n- `template_name` (str): Template filename\n- `output_path` (Path)\n- `context` (dict[str, Any])\n- `create_dirs` (bool)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `_generate_docker_setup` 的作用。"}, {"role": "assistant", "content": "`_generate_docker_setup` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/commands/init.py`。\n**功能描述**：\nGenerate Docker configuration.\n**函数签名**：\n```python\ndef _generate_docker_setup(project_path: Path) -> None:\n```\n**参数**：\n- `project_path` (Path)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `RedisBus` 的作用。"}, {"role": "assistant", "content": "`RedisBus` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/core/message_bus.py`。\n**功能描述**：\nRedis-based message bus for production use. Uses Redis Streams for task queues and pub/sub for responses. Agents are registered in a hash with metadata and heartbeats.\n**函数签名**：\n```python\nclass RedisBus:\n```"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`check_docker` 有什么功能？"}, {"role": "assistant", "content": "`check_docker` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/utils/docker.py`。\n**功能描述**：\nCheck if Docker is installed and running. Returns: True if Docker is available Raises: DockerNotFoundError: If Docker is not found or not running\n**函数签名**：\n```python\ndef check_docker() -> bool:\n```\n**返回值**：`bool`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`MCPToolRegistry.__init__` 方法在哪个文件里？"}, {"role": "assistant", "content": "`MCPToolRegistry.__init__` 位于 `lib/laddr/src/laddr/core/mcp_client.py`。"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`InMemoryCache.set` 有什么功能？"}, {"role": "assistant", "content": "`InMemoryCache.set` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/cache.py`。\n**功能描述**：\nSet value in cache with optional TTL (seconds).\n**函数签名**：\n```python\ndef set(self, key: str, value: Any, ttl: int | None = None) -> None:\n```\n**参数**：\n- `self` (Any)\n- `key` (str)\n- `value` (Any)\n- `ttl` (int | None)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `DatabaseService.list_jobs` 函数？"}, {"role": "assistant", "content": "`DatabaseService.list_jobs` 位于 `lib/laddr/src/laddr/core/database.py`，使用方法如下：\n```python\nDatabaseService.list_jobs(limit=...)\n```\n**参数说明**：\n- `limit`: int\n\n**功能简述**：List recent jobs...."}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `CacheBackend.delete` 函数？"}, {"role": "assistant", "content": "`CacheBackend.delete` 位于 `lib/laddr/src/laddr/core/config.py`，使用方法如下：\n```python\nCacheBackend.delete(key=...)\n```\n**参数说明**：\n- `key`: str"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`compose_down` 有什么功能？"}, {"role": "assistant", "content": "`compose_down` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/utils/docker.py`。\n**功能描述**：\nStop Docker Compose services. Args: remove_volumes: Remove named volumes (default: False) Raises: DockerComposeError: If compose down fails\n**函数签名**：\n```python\ndef compose_down(remove_volumes: bool = False) -> None:\n```\n**参数**：\n- `remove_volumes` (bool): Remove named volumes (default: False)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`compose_ps` 有什么功能？"}, {"role": "assistant", "content": "`compose_ps` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/utils/docker.py`。\n**功能描述**：\nGet status of Docker Compose services. Args: services: Optional list of specific services to check Returns: Status output as string Raises: DockerComposeError: If compose ps fails\n**函数签名**：\n```python\ndef compose_ps(services: list[str] | None = None) -> str:\n```\n**参数**：\n- `services` (list[str] | None): Optional list of specific services to check\n\n**返回值**：`str`"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `BackendFactory.create_database_backend` 是做什么的？"}, {"role": "assistant", "content": "`BackendFactory.create_database_backend` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/config.py`。\n**功能描述**：\nCreate database backend based on config.\n**函数签名**：\n```python\ndef create_database_backend(self) -> DatabaseBackend:\n```\n**参数**：\n- `self` (Any)\n\n**返回值**：`DatabaseBackend`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `DatabaseService.save_prompt_result` 函数？"}, {"role": "assistant", "content": "`DatabaseService.save_prompt_result` 位于 `lib/laddr/src/laddr/core/database.py`，使用方法如下：\n```python\nDatabaseService.save_prompt_result(prompt_id=..., outputs=..., status=...)\n```\n**参数说明**：\n- `prompt_id`: str\n- `outputs`: dict\n- `status`: str\n\n**功能简述**：Save prompt execution result...."}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`MemoryBus.__init__` 方法在哪个文件里？"}, {"role": "assistant", "content": "`MemoryBus.__init__` 位于 `lib/laddr/src/laddr/core/message_bus.py`。"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `logs` 函数？"}, {"role": "assistant", "content": "`logs` 位于 `lib/laddr/src/laddr/cli/commands/management.py`，使用方法如下：\n```python\nlogs(agent_name=..., follow=..., tail=...)\n```\n**参数说明**：\n- `agent_name`: str\n- `follow`: bool\n- `tail`: int | None\n\n**功能简述**：View logs for an agent worker. Examples: laddr logs researcher laddr logs researcher --follow laddr logs researcher --tail 100..."}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `TemplateRenderer.render_string` 是做什么的？"}, {"role": "assistant", "content": "`TemplateRenderer.render_string` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/cli/utils/templates.py`。\n**功能描述**：\nRender a template string with context. Args: template_str: Template string context: Template context variables Returns: Rendered content Raises: FileGenerationError: If rendering fails\n**函数签名**：\n```python\ndef render_string(self, template_str: str, context: dict[str, Any]) -> str:\n```\n**参数**：\n- `self` (Any)\n- `template_str` (str): Template string\n- `context` (dict[str, Any])\n\n**返回值**：`str`"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `AgentRunner._start_inline_workers` 是做什么的？"}, {"role": "assistant", "content": "`AgentRunner._start_inline_workers` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/runtime_entry.py`。\n**功能描述**：\nStart a background task that consumes tasks and runs target agents inline.\n**函数签名**：\n```python\ndef _start_inline_workers(self, agent_names: list[str]) -> None:\n```\n**参数**：\n- `self` (Any)\n- `agent_names` (list[str])\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `run_pipeline` 函数？"}, {"role": "assistant", "content": "`run_pipeline` 位于 `lib/laddr/src/laddr/cli/commands/run.py`，使用方法如下：\n```python\nrun_pipeline(pipeline_file=...)\n```\n**参数说明**：\n- `pipeline_file`: str\n\n**功能简述**：Run a pipeline defined in a YAML file...."}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `SubmitJobRequest` 的作用。"}, {"role": "assistant", "content": "`SubmitJobRequest` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/api/main.py`。\n**功能描述**：\nRequest to submit a new job (legacy).\n**函数签名**：\n```python\nclass SubmitJobRequest(BaseModel):\n```"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`ParallelDelegationTool.split_document` 方法在哪个文件里？"}, {"role": "assistant", "content": "`ParallelDelegationTool.split_document` 位于 `lib/laddr/src/laddr/core/system_tools.py`。"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `DatabaseService.list_traces` 的作用。"}, {"role": "assistant", "content": "`DatabaseService.list_traces` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/database.py`。\n**功能描述**：\nList recent traces, optionally filtered by agent.\n**函数签名**：\n```python\ndef list_traces(self, agent: str | None = None, limit: int = 100) -> list[dict]:\n```\n**参数**：\n- `self` (Any)\n- `agent` (str | None)\n- `limit` (int)\n\n**返回值**：`list[dict]`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`EventThrottler.add` 有什么功能？"}, {"role": "assistant", "content": "`EventThrottler.add` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/api/main.py`。\n**功能描述**：\nAdd event, return it if should be sent immediately.\n**函数签名**：\n```python\ndef add(self, event: dict) -> dict | None:\n```\n**参数**：\n- `self` (Any)\n- `event` (dict)\n\n**返回值**：`dict | None`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`_create_directories` 函数在哪个文件里？"}, {"role": "assistant", "content": "`_create_directories` 位于 `lib/laddr/src/laddr/cli/commands/init.py`。"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `Agent.__init__` 函数？"}, {"role": "assistant", "content": "`Agent.__init__` 位于 `lib/laddr/src/laddr/core/agent_runtime.py`，使用方法如下：\n```python\nAgent.__init__(config=..., env_config=..., tools=...)\n```\n**参数说明**：\n- `config`: AgentConfig - Agent-specific configuration\n- `env_config`: LaddrConfig | None\n- `tools`: ToolRegistry | list[Any] | None\n\n**功能简述**：Initialize agent. Args: config: Agent-specific configuration env_config: Environment configuration (loaded if None) tools: Tool registry (auto-discovered if None)..."}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `Agent._build_autonomous_user_prompt` 函数？"}, {"role": "assistant", "content": "`Agent._build_autonomous_user_prompt` 位于 `lib/laddr/src/laddr/core/agent_runtime.py`，使用方法如下：\n```python\nAgent._build_autonomous_user_prompt(task_description=..., history=..., iteration=...)\n```\n**参数说明**：\n- `task_description`: str\n- `history`: list[dict]\n- `iteration`: int\n\n**功能简述**：Build user prompt with task and history...."}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`TaskMessage.from_dict` 方法在哪个文件里？"}, {"role": "assistant", "content": "`TaskMessage.from_dict` 位于 `lib/laddr/src/laddr/core/message_bus.py`。"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `ParallelDelegationTool` 的作用。"}, {"role": "assistant", "content": "`ParallelDelegationTool` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/core/system_tools.py`。\n**功能描述**：\nTool for delegating multiple tasks in parallel (sharding/fan-out pattern).\n**函数签名**：\n```python\nclass ParallelDelegationTool:\n```"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `DatabaseService.get_metrics` 函数？"}, {"role": "assistant", "content": "`DatabaseService.get_metrics` 位于 `lib/laddr/src/laddr/core/database.py`，使用方法如下：\n**参数说明**：\n\n**功能简述**：Get aggregated metrics...."}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `TemplateRenderer.__init__` 函数？"}, {"role": "assistant", "content": "`TemplateRenderer.__init__` 位于 `lib/laddr/src/laddr/cli/utils/templates.py`，使用方法如下：\n```python\nTemplateRenderer.__init__(templates_dir=...)\n```\n**参数说明**：\n- `templates_dir`: Path - Directory containing Jinja2 templates\n\n**功能简述**：Initialize template renderer. Args: templates_dir: Directory containing Jinja2 templates..."}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `DatabaseService.append_trace` 是做什么的？"}, {"role": "assistant", "content": "`DatabaseService.append_trace` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/database.py`。\n**功能描述**：\nAppend a trace event.\n**函数签名**：\n```python\ndef append_trace(self, job_id: str, agent_name: str, event_type: str, payload: dict) -> None:\n```\n**参数**：\n- `self` (Any)\n- `job_id` (str)\n- `agent_name` (str)\n- `event_type` (str)\n- `payload` (dict)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`AgentConfig` 有什么功能？"}, {"role": "assistant", "content": "`AgentConfig` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/core/config.py`。\n**功能描述**：\nAgent configuration (minimal for @actor pattern). Most runtime config is auto-discovered or comes from LaddrConfig.\n**函数签名**：\n```python\nclass AgentConfig(BaseModel):\n```"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `PipelineConfig` 是做什么的？"}, {"role": "assistant", "content": "`PipelineConfig` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/core/config.py`。\n**功能描述**：\nPipeline configuration for sequential agent execution.\n**函数签名**：\n```python\nclass PipelineConfig(BaseModel):\n```"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`WorkerRunner.__init__` 方法在哪个文件里？"}, {"role": "assistant", "content": "`WorkerRunner.__init__` 位于 `lib/laddr/src/laddr/core/runtime_entry.py`。"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `check` 函数？"}, {"role": "assistant", "content": "`check` 位于 `lib/laddr/src/laddr/cli/commands/check.py`，使用方法如下：\n```python\ncheck(output_path=...)\n```\n**参数说明**：\n- `output_path`: str\n\n**功能简述**：Run diagnostic checks for the Laddr runtime using the DiagnosticAgent...."}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`cli` 函数在哪个文件里？"}, {"role": "assistant", "content": "`cli` 位于 `lib/laddr/src/laddr/cli/main.py`。"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `DatabaseService.__init__` 函数？"}, {"role": "assistant", "content": "`DatabaseService.__init__` 位于 `lib/laddr/src/laddr/core/database.py`，使用方法如下：\n```python\nDatabaseService.__init__(database_url=...)\n```\n**参数说明**：\n- `database_url`: str - SQLAlchemy connection string\n\n**功能简述**：Initialize database service. Args: database_url: SQLAlchemy connection string e.g., \"postgresql://user:pass@host:5432/db\" or \"sqlite:///./laddr.db\" for local dev..."}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`SubmitPromptRequest` 有什么功能？"}, {"role": "assistant", "content": "`SubmitPromptRequest` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/api/main.py`。\n**功能描述**：\nRequest to submit a new prompt execution.\n**函数签名**：\n```python\nclass SubmitPromptRequest(BaseModel):\n```"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `ToolRegistry.list_all_names` 函数？"}, {"role": "assistant", "content": "`ToolRegistry.list_all_names` 位于 `lib/laddr/src/laddr/core/tooling.py`，使用方法如下：\n**参数说明**：\n\n**功能简述**：List all names including aliases (for debugging)...."}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`ParallelDelegationTool.split_document` 有什么功能？"}, {"role": "assistant", "content": "`ParallelDelegationTool.split_document` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/system_tools.py`。\n**功能描述**：\nSplit a large document into smaller chunks for parallel processing. Use this before calling delegate_parallel to divide large documents into manageable sections that can be processed by multiple workers. Parameters: - document: The document text to split - num_chunks: Number of chunks to split into (e.g., 3 for 3 workers) - overlap: Number of characters to overlap between chunks (for context continuity) Returns: - chunks: List of document chunks - metadata: Information about the split (lengths, chunk count, etc.)\n**函数签名**：\n```python\ndef split_document(\nself,\ndocument: str,\nnum_chunks: int = 3,\noverlap: int = 0\n```\n**参数**：\n- `self` (Any)\n- `document` (str): The document text to split\n- `num_chunks` (int)\n- `overlap` (int)\n\n**返回值**：`dict`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `CacheBackend.clear` 函数？"}, {"role": "assistant", "content": "`CacheBackend.clear` 位于 `lib/laddr/src/laddr/core/config.py`，使用方法如下：\n**参数说明**："}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`DockerComposeError` 有什么功能？"}, {"role": "assistant", "content": "`DockerComposeError` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/cli/utils/errors.py`。\n**功能描述**：\nRaised when Docker Compose operations fail.\n**函数签名**：\n```python\nclass DockerComposeError(LaddrError):\n```"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `InvalidInputError` 的作用。"}, {"role": "assistant", "content": "`InvalidInputError` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/cli/utils/errors.py`。\n**功能描述**：\nRaised when user input is invalid.\n**函数签名**：\n```python\nclass InvalidInputError(LaddrError):\n```"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`DatabaseService.save_result` 有什么功能？"}, {"role": "assistant", "content": "`DatabaseService.save_result` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/database.py`。\n**功能描述**：\nSave job result.\n**函数签名**：\n```python\ndef save_result(self, job_id: str, outputs: dict, status: str = \"completed\") -> None:\n```\n**参数**：\n- `self` (Any)\n- `job_id` (str)\n- `outputs` (dict)\n- `status` (str)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `get_logger` 是做什么的？"}, {"role": "assistant", "content": "`get_logger` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/utils/logger.py`。\n**功能描述**：\nGet a configured logger with rich handler. Args: name: Logger name (usually __name__) level: Log level (default: INFO) Returns: Configured logger instance\n**函数签名**：\n```python\ndef get_logger(name: str, level: int = logging.INFO) -> logging.Logger:\n```\n**参数**：\n- `name` (str): Logger name (usually __name__)\n- `level` (int)\n\n**返回值**：`logging.Logger`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `AgentRunner._stop_inline_workers` 函数？"}, {"role": "assistant", "content": "`AgentRunner._stop_inline_workers` 位于 `lib/laddr/src/laddr/core/runtime_entry.py`，使用方法如下：\n**参数说明**："}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`AgentMemory.put` 有什么功能？"}, {"role": "assistant", "content": "`AgentMemory.put` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/agent_runtime.py`。\n**功能描述**：\nStore a memory entry.\n**函数签名**：\n```python\ndef put(self, key: str, value: Any) -> None:\n```\n**参数**：\n- `self` (Any)\n- `key` (str)\n- `value` (Any)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `DatabaseService.memory_list` 函数？"}, {"role": "assistant", "content": "`DatabaseService.memory_list` 位于 `lib/laddr/src/laddr/core/database.py`，使用方法如下：\n```python\nDatabaseService.memory_list(agent_name=..., job_id=...)\n```\n**参数说明**：\n- `agent_name`: str\n- `job_id`: str | None\n\n**功能简述**：List all memory entries for an agent...."}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `DatabaseService.memory_list` 的作用。"}, {"role": "assistant", "content": "`DatabaseService.memory_list` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/database.py`。\n**功能描述**：\nList all memory entries for an agent.\n**函数签名**：\n```python\ndef memory_list(self, agent_name: str, job_id: str | None = None) -> dict[str, Any]:\n```\n**参数**：\n- `self` (Any)\n- `agent_name` (str)\n- `job_id` (str | None)\n\n**返回值**：`dict[str, Any]`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`check` 函数在哪个文件里？"}, {"role": "assistant", "content": "`check` 位于 `lib/laddr/src/laddr/cli/commands/check.py`。"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `S3Storage.__init__` 的作用。"}, {"role": "assistant", "content": "`S3Storage.__init__` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/storage.py`。\n**功能描述**：\nInitialize S3-compatible storage. Args: endpoint: S3 endpoint (e.g., \"s3.amazonaws.com\" or \"minio:9000\") access_key: Access key (AWS Access Key ID or MinIO access key) secret_key: Secret key (AWS Secret Access Key or MinIO secret key) secure: Use HTTPS (True for AWS S3, False for local MinIO) region: AWS region (optional, e.g., \"us-east-1\")\n**函数签名**：\n```python\ndef __init__(\nself,\nendpoint: str,\naccess_key: str,\nsecret_key: str,\n```\n**参数**：\n- `self` (Any)\n- `endpoint` (str): S3 endpoint (e.g., \"s3.amazonaws.com\" or \"minio:9000\")\n- `access_key` (str)\n- `secret_key` (str)\n- `secure` (bool)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `Agent._discover_tool_overrides` 函数？"}, {"role": "assistant", "content": "`Agent._discover_tool_overrides` 位于 `lib/laddr/src/laddr/core/agent_runtime.py`，使用方法如下：\n**参数说明**：\n\n**功能简述**：Auto-discover and load tool override modules from the project. Searches common locations for tool override files: - ./tools/overrides/ - ./custom_tools/ - ./agent_tools/overrides/ When override module..."}]}
{"conversations": [{"role": "user", "content": "Laddr 的项目结构是怎样的？"}, {"role": "assistant", "content": "Laddr 项目包含以下主要部分：\n\n**核心模块**：\n- `core` (核心逻辑，如Agent Runtime, Tooling, Config)\n- `cli` (命令行接口)\n- `llms` (LLM后端实现)\n\n**主要文件类型统计**：MD: 15, TOML: 2, YML: 1, TXT: 1, SH: 3, LOCK: 1, PNG: 1, SVG: 4, EXAMPLE: 1, HTML: 1, CONF: 1, JSON: 4, JS: 2, TS: 15, PROD: 1, TEMPLATE: 1, TSX: 15, CSS: 2, PY: 32, J2: 10"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `DatabaseService.list_prompts` 是做什么的？"}, {"role": "assistant", "content": "`DatabaseService.list_prompts` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/database.py`。\n**功能描述**：\nList recent prompt executions.\n**函数签名**：\n```python\ndef list_prompts(self, limit: int = 50) -> list[dict]:\n```\n**参数**：\n- `self` (Any)\n- `limit` (int)\n\n**返回值**：`list[dict]`"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `InvalidConfigError` 的作用。"}, {"role": "assistant", "content": "`InvalidConfigError` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/cli/utils/errors.py`。\n**功能描述**：\nRaised when configuration files are invalid.\n**函数签名**：\n```python\nclass InvalidConfigError(LaddrError):\n```"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`override_system_tool` 有什么功能？"}, {"role": "assistant", "content": "`override_system_tool` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/core/system_tools.py`。\n**功能描述**：\nDecorator to override a system tool with a custom implementation. Use this decorator to replace built-in system tools (like system_delegate_parallel, system_split_document, etc.) with your own implementations. Example: from laddr.core.system_tools import override_system_tool @override_system_tool(\"system_delegate_parallel\") async def my_custom_parallel_delegation(agent_name: str, tasks: list[str], **kwargs): # Your custom implementation print(f\"Custom parallel delegation: {len(tasks)} tasks to {agent_name}\") return {\"status\": \"success\", \"results\": [...]} Args: tool_name: Name of the system tool to override (e.g., \"system_delegate_parallel\") Returns: Decorator function that registers the override\n**函数签名**：\n```python\ndef override_system_tool(tool_name: str):\n```\n**参数**：\n- `tool_name` (str): Name of the system tool to override (e.g., \"system_delegate_parallel\")\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `OpenAILLM.__init__` 函数？"}, {"role": "assistant", "content": "`OpenAILLM.__init__` 位于 `lib/laddr/src/laddr/core/llm.py`，使用方法如下：\n```python\nOpenAILLM.__init__(api_key=..., model=..., base_url=...)\n```\n**参数说明**：\n- `api_key`: str | None\n- `model`: str | None\n- `base_url`: str | None"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `logs` 的作用。"}, {"role": "assistant", "content": "`logs` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/commands/management.py`。\n**功能描述**：\nView logs for an agent worker. Examples: laddr logs researcher laddr logs researcher --follow laddr logs researcher --tail 100\n**函数签名**：\n```python\ndef logs(agent_name: str, follow: bool, tail: int | None):\n```\n**参数**：\n- `agent_name` (str)\n- `follow` (bool)\n- `tail` (int | None)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`ArtifactStorageTool.__init__` 方法在哪个文件里？"}, {"role": "assistant", "content": "`ArtifactStorageTool.__init__` 位于 `lib/laddr/src/laddr/core/system_tools.py`。"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`print_error` 有什么功能？"}, {"role": "assistant", "content": "`print_error` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/utils/logger.py`。\n**功能描述**：\nPrint an error message. Args: message: Error message hint: Optional hint for resolution\n**函数签名**：\n```python\ndef print_error(message: str, hint: str | None = None) -> None:\n```\n**参数**：\n- `message` (str): Error message\n- `hint` (str | None)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `BackendFactory.create_storage_backend` 是做什么的？"}, {"role": "assistant", "content": "`BackendFactory.create_storage_backend` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/config.py`。\n**功能描述**：\nCreate S3-compatible storage backend (AWS S3, MinIO, or compatible). Supports backward compatibility with old minio_* field names.\n**函数签名**：\n```python\ndef create_storage_backend(self):\n```\n**参数**：\n- `self` (Any)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `AgentRunner._start_inline_workers` 函数？"}, {"role": "assistant", "content": "`AgentRunner._start_inline_workers` 位于 `lib/laddr/src/laddr/core/runtime_entry.py`，使用方法如下：\n```python\nAgentRunner._start_inline_workers(agent_names=...)\n```\n**参数说明**：\n- `agent_names`: list[str]\n\n**功能简述**：Start a background task that consumes tasks and runs target agents inline...."}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `DatabaseService.memory_get` 函数？"}, {"role": "assistant", "content": "`DatabaseService.memory_get` 位于 `lib/laddr/src/laddr/core/database.py`，使用方法如下：\n```python\nDatabaseService.memory_get(agent_name=..., key=..., job_id=...)\n```\n**参数说明**：\n- `agent_name`: str\n- `key`: str\n- `job_id`: str | None\n\n**功能简述**：Retrieve a memory entry...."}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `scale` 是做什么的？"}, {"role": "assistant", "content": "`scale` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/commands/management.py`。\n**功能描述**：\nScale an agent worker to N replicas. Examples: laddr scale researcher 3 laddr scale summarizer 0  # Stop all replicas\n**函数签名**：\n```python\ndef scale(agent_name: str, replicas: int):\n```\n**参数**：\n- `agent_name` (str)\n- `replicas` (int)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `BackendFactory.create_cache_backend` 的作用。"}, {"role": "assistant", "content": "`BackendFactory.create_cache_backend` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/config.py`。\n**功能描述**：\nCreate cache backend based on config.\n**函数签名**：\n```python\ndef create_cache_backend(self) -> CacheBackend:\n```\n**参数**：\n- `self` (Any)\n\n**返回值**：`CacheBackend`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `AgentMemory.get` 函数？"}, {"role": "assistant", "content": "`AgentMemory.get` 位于 `lib/laddr/src/laddr/core/agent_runtime.py`，使用方法如下：\n```python\nAgentMemory.get(key=...)\n```\n**参数说明**：\n- `key`: str\n\n**功能简述**：Retrieve a memory entry...."}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `ProjectConfigSchema.save_to_file` 函数？"}, {"role": "assistant", "content": "`ProjectConfigSchema.save_to_file` 位于 `lib/laddr/src/laddr/cli/utils/config.py`，使用方法如下：\n```python\nProjectConfigSchema.save_to_file(path=...)\n```\n**参数说明**：\n- `path`: Path - Path to laddr.yml\n\n**功能简述**：Save project config to YAML file. Args: path: Path to laddr.yml Raises: InvalidConfigError: If save fails..."}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `create_system_tools` 的作用。"}, {"role": "assistant", "content": "`create_system_tools` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/core/system_tools.py`。\n**功能描述**：\nCreate system tools for task delegation and artifact management. This function checks for user-provided overrides before registering the default implementations. Users can use @override_system_tool decorator to replace any system tool OR create entirely new system tools. Args: message_bus: Message queue backend storage_backend: Optional storage backend (MinIO/S3) agent: Optional agent instance for accessing current_job_id context Returns: Dict mapping tool names to (tool_function, aliases) tuples\n**函数签名**：\n```python\ndef create_system_tools(message_bus, storage_backend=None, agent=None) -> dict[str, tuple[Any, list[str]]]:\n```\n**参数**：\n- `message_bus` (Any): Message queue backend\n- `storage_backend` (Any)\n- `agent` (Any)\n\n**返回值**：`dict[str, tuple[Any, list[str]]]`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `BackendFactory.create_llm_backend` 函数？"}, {"role": "assistant", "content": "`BackendFactory.create_llm_backend` 位于 `lib/laddr/src/laddr/core/config.py`，使用方法如下：\n```python\nBackendFactory.create_llm_backend(override=..., model_override=..., agent_name=...)\n```\n**参数说明**：\n- `override`: str | None\n- `model_override`: str | None\n- `agent_name`: str | None\n\n**功能简述**：Create LLM backend based on config. If `override` is provided it takes precedence over the global `LaddrConfig.llm_backend`. `model_override` can be provided to select a different model for an agent...."}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `DatabaseBackend.list_jobs` 函数？"}, {"role": "assistant", "content": "`DatabaseBackend.list_jobs` 位于 `lib/laddr/src/laddr/core/config.py`，使用方法如下：\n```python\nDatabaseBackend.list_jobs(limit=...)\n```\n**参数说明**：\n- `limit`: int"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`validate_project_directory` 函数在哪个文件里？"}, {"role": "assistant", "content": "`validate_project_directory` 位于 `lib/laddr/src/laddr/cli/utils/config.py`。"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`DatabaseService.create_job` 有什么功能？"}, {"role": "assistant", "content": "`DatabaseService.create_job` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/database.py`。\n**功能描述**：\nCreate a new job record, or reuse existing if job_id already exists (for sequential chains).\n**函数签名**：\n```python\ndef create_job(self, job_id: str | None, pipeline: str, inputs: dict) -> str:\n```\n**参数**：\n- `self` (Any)\n- `job_id` (str | None)\n- `pipeline` (str)\n- `inputs` (dict)\n\n**返回值**：`str`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `Agent._parse_autonomous_action` 函数？"}, {"role": "assistant", "content": "`Agent._parse_autonomous_action` 位于 `lib/laddr/src/laddr/core/agent_runtime.py`，使用方法如下：\n```python\nAgent._parse_autonomous_action(response=...)\n```\n**参数说明**：\n- `response`: str\n\n**功能简述**：Parse LLM response to extract action, preferring JSON format with text fallback...."}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `DatabaseService.list_agents` 是做什么的？"}, {"role": "assistant", "content": "`DatabaseService.list_agents` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/database.py`。\n**功能描述**：\nList all registered agents with trace counts and last execution time.\n**函数签名**：\n```python\ndef list_agents(self) -> list[dict]:\n```\n**参数**：\n- `self` (Any)\n\n**返回值**：`list[dict]`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`run_agent_cmd` 函数在哪个文件里？"}, {"role": "assistant", "content": "`run_agent_cmd` 位于 `lib/laddr/src/laddr/cli/commands/run.py`。"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`DatabaseService.get_trace` 方法在哪个文件里？"}, {"role": "assistant", "content": "`DatabaseService.get_trace` 位于 `lib/laddr/src/laddr/core/database.py`。"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`ArtifactStorageTool` 有什么功能？"}, {"role": "assistant", "content": "`ArtifactStorageTool` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/core/system_tools.py`。\n**功能描述**：\nTool for storing and retrieving large data artifacts. Backward-compatible retrieval: - Old style: by artifact_id and artifact_type (stored under default artifact bucket) - New style: by bucket+key (e.g., offloaded response pointers)\n**函数签名**：\n```python\nclass ArtifactStorageTool:\n```"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `NoOpLLM` 是做什么的？"}, {"role": "assistant", "content": "`NoOpLLM` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/core/llm.py`。\n**功能描述**：\nNo-op LLM backend that echoes prompts. Useful for testing and local dev without API keys.\n**函数签名**：\n```python\nclass NoOpLLM:\n```"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `_LLMWithDefaults` 的作用。"}, {"role": "assistant", "content": "`_LLMWithDefaults` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/llms.py`。\n**功能描述**：\nWrap an LLM backend with default params for generate().\n**函数签名**：\n```python\nclass _LLMWithDefaults:\n```"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `ToolRegistry.get` 函数？"}, {"role": "assistant", "content": "`ToolRegistry.get` 位于 `lib/laddr/src/laddr/core/tooling.py`，使用方法如下：\n```python\nToolRegistry.get(name=...)\n```\n**参数说明**：\n- `name`: str - Tool name (canonical or alias)\n\n**功能简述**：Get a tool by name or alias. Args: name: Tool name (canonical or alias) Returns: Tool instance or None if not found..."}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `ProjectConfigSchema` 的作用。"}, {"role": "assistant", "content": "`ProjectConfigSchema` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/cli/utils/config.py`。\n**功能描述**：\nProject configuration schema (laddr.yml).\n**函数签名**：\n```python\nclass ProjectConfigSchema(BaseModel):\n```"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `AgentMemory` 的作用。"}, {"role": "assistant", "content": "`AgentMemory` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/core/agent_runtime.py`。\n**功能描述**：\nMemory interface for agents.\n**函数签名**：\n```python\nclass AgentMemory:\n```"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `print_error` 函数？"}, {"role": "assistant", "content": "`print_error` 位于 `lib/laddr/src/laddr/cli/utils/logger.py`，使用方法如下：\n```python\nprint_error(message=..., hint=...)\n```\n**参数说明**：\n- `message`: str - Error message\n- `hint`: str | None\n\n**功能简述**：Print an error message. Args: message: Error message hint: Optional hint for resolution..."}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `run_prompt` 函数？"}, {"role": "assistant", "content": "`run_prompt` 位于 `lib/laddr/src/laddr/cli/commands/prompt.py`，使用方法如下：\n```python\nrun_prompt(prompt_name=..., inputs=..., json_input=..., wait=..., timeout=...)\n```\n**参数说明**：\n- `prompt_name`: str\n- `inputs`: tuple\n- `json_input`: str | None\n- `wait`: bool\n- `timeout`: int\n\n**功能简述**：Run a prompt execution. Examples: laddr prompt run researcher --input query=\"AI trends\" laddr prompt run researcher --json '{\"query\": \"AI trends\"}' laddr prompt run researcher --json @inputs.json..."}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `DatabaseBackend.create_job` 函数？"}, {"role": "assistant", "content": "`DatabaseBackend.create_job` 位于 `lib/laddr/src/laddr/core/config.py`，使用方法如下：\n```python\nDatabaseBackend.create_job(job_id=..., pipeline=..., inputs=...)\n```\n**参数说明**：\n- `job_id`: str\n- `pipeline`: str\n- `inputs`: dict"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `ToolRegistry.list` 函数？"}, {"role": "assistant", "content": "`ToolRegistry.list` 位于 `lib/laddr/src/laddr/core/tooling.py`，使用方法如下：\n**参数说明**：\n\n**功能简述**：List all registered tools (excludes aliases)...."}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `prompt` 是做什么的？"}, {"role": "assistant", "content": "`prompt` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/commands/prompt.py`。\n**功能描述**：\nRun and manage prompt executions.\n**函数签名**：\n```python\ndef prompt():\n```\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`MCPToolSource.__init__` 方法在哪个文件里？"}, {"role": "assistant", "content": "`MCPToolSource.__init__` 位于 `lib/laddr/src/laddr/core/mcp_client.py`。"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `DatabaseService.list_traces` 函数？"}, {"role": "assistant", "content": "`DatabaseService.list_traces` 位于 `lib/laddr/src/laddr/core/database.py`，使用方法如下：\n```python\nDatabaseService.list_traces(agent=..., limit=...)\n```\n**参数说明**：\n- `agent`: str | None\n- `limit`: int\n\n**功能简述**：List recent traces, optionally filtered by agent...."}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`TemplateRenderer._kebab_case` 有什么功能？"}, {"role": "assistant", "content": "`TemplateRenderer._kebab_case` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/cli/utils/templates.py`。\n**功能描述**：\nConvert string to kebab-case.\n**函数签名**：\n```python\ndef _kebab_case(value: str) -> str:\n```\n**参数**：\n- `value` (str)\n\n**返回值**：`str`"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `add` 的作用。"}, {"role": "assistant", "content": "`add` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/commands/add.py`。\n**功能描述**：\nAdd resources to your project (agents, tools).\n**函数签名**：\n```python\ndef add():\n```\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`_print_management_commands` 函数在哪个文件里？"}, {"role": "assistant", "content": "`_print_management_commands` 位于 `lib/laddr/src/laddr/cli/commands/run.py`。"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `DatabaseService.register_agent` 的作用。"}, {"role": "assistant", "content": "`DatabaseService.register_agent` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/database.py`。\n**功能描述**：\nRegister or update an agent in the registry.\n**函数签名**：\n```python\ndef register_agent(self, agent_name: str, metadata: dict) -> None:\n```\n**参数**：\n- `self` (Any)\n- `agent_name` (str)\n- `metadata` (dict)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `ProjectDetails` 是做什么的？"}, {"role": "assistant", "content": "`ProjectDetails` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/cli/utils/config.py`。\n**功能描述**：\nProject details section.\n**函数签名**：\n```python\nclass ProjectDetails(BaseModel):\n```"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`print_panel` 有什么功能？"}, {"role": "assistant", "content": "`print_panel` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/utils/logger.py`。\n**功能描述**：\nPrint a styled panel. Args: title: Panel title content: Panel content style: Panel border style (default: cyan)\n**函数签名**：\n```python\ndef print_panel(title: str, content: str, style: str = \"cyan\") -> None:\n```\n**参数**：\n- `title` (str): Panel title\n- `content` (str)\n- `style` (str)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `BackendFactory.create_queue_backend` 是做什么的？"}, {"role": "assistant", "content": "`BackendFactory.create_queue_backend` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/config.py`。\n**功能描述**：\nCreate message queue backend based on config.\n**函数签名**：\n```python\ndef create_queue_backend(self) -> QueueBackend:\n```\n**参数**：\n- `self` (Any)\n\n**返回值**：`QueueBackend`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `print_warning` 函数？"}, {"role": "assistant", "content": "`print_warning` 位于 `lib/laddr/src/laddr/cli/utils/logger.py`，使用方法如下：\n```python\nprint_warning(message=...)\n```\n**参数说明**：\n- `message`: str - Warning message\n\n**功能简述**：Print a warning message. Args: message: Warning message..."}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `stop` 是做什么的？"}, {"role": "assistant", "content": "`stop` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/commands/management.py`。\n**功能描述**：\nStop all Laddr services. Examples: laddr stop laddr stop --volumes  # Also remove data volumes\n**函数签名**：\n```python\ndef stop(volumes: bool):\n```\n**参数**：\n- `volumes` (bool)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `Tool.invoke` 是做什么的？"}, {"role": "assistant", "content": "`Tool.invoke` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/tooling.py`。\n**功能描述**：\nInvoke the tool with validated inputs. Returns tool execution result.\n**函数签名**：\n```python\ndef invoke(self, **kwargs) -> Any:\n```\n**参数**：\n- `self` (Any)\n\n**返回值**：`Any`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `replay_job` 函数？"}, {"role": "assistant", "content": "`replay_job` 位于 `lib/laddr/src/laddr/cli/commands/run.py`，使用方法如下：\n```python\nreplay_job(job_id=..., reexecute=...)\n```\n**参数说明**：\n- `job_id`: str\n- `reexecute`: bool\n\n**功能简述**：Replay a previous job by job ID. Examples: laddr run replay abc123-456-def laddr run replay abc123-456-def --reexecute..."}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `InMemoryCache.delete` 的作用。"}, {"role": "assistant", "content": "`InMemoryCache.delete` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/cache.py`。\n**功能描述**：\nDelete value from cache.\n**函数签名**：\n```python\ndef delete(self, key: str) -> None:\n```\n**参数**：\n- `self` (Any)\n- `key` (str)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `print_info` 函数？"}, {"role": "assistant", "content": "`print_info` 位于 `lib/laddr/src/laddr/cli/utils/logger.py`，使用方法如下：\n```python\nprint_info(message=...)\n```\n**参数说明**：\n- `message`: str - Info message\n\n**功能简述**：Print an info message. Args: message: Info message..."}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`create_tool_schema` 函数在哪个文件里？"}, {"role": "assistant", "content": "`create_tool_schema` 位于 `lib/laddr/src/laddr/core/tooling.py`。"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`InMemoryStorage.__init__` 方法在哪个文件里？"}, {"role": "assistant", "content": "`InMemoryStorage.__init__` 位于 `lib/laddr/src/laddr/core/storage.py`。"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `Agent._tool_cache_key` 函数？"}, {"role": "assistant", "content": "`Agent._tool_cache_key` 位于 `lib/laddr/src/laddr/core/agent_runtime.py`，使用方法如下：\n```python\nAgent._tool_cache_key(name=..., params=...)\n```\n**参数说明**：\n- `name`: str\n- `params`: dict\n\n**功能简述**：Generate cache key for tool call...."}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `DatabaseService.list_agents` 函数？"}, {"role": "assistant", "content": "`DatabaseService.list_agents` 位于 `lib/laddr/src/laddr/core/database.py`，使用方法如下：\n**参数说明**：\n\n**功能简述**：List all registered agents with trace counts and last execution time...."}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `print_table` 函数？"}, {"role": "assistant", "content": "`print_table` 位于 `lib/laddr/src/laddr/cli/utils/logger.py`，使用方法如下：\n```python\nprint_table(data=..., title=...)\n```\n**参数说明**：\n- `data`: list[dict] - List of dictionaries (each dict is a row)\n- `title`: str | None\n\n**功能简述**：Print data as a rich table. Args: data: List of dictionaries (each dict is a row) title: Optional table title..."}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `ProjectExistsError` 的作用。"}, {"role": "assistant", "content": "`ProjectExistsError` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/cli/utils/errors.py`。\n**功能描述**：\nRaised when trying to create a project that already exists.\n**函数签名**：\n```python\nclass ProjectExistsError(LaddrError):\n```"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `anthropic` 函数？"}, {"role": "assistant", "content": "`anthropic` 位于 `lib/laddr/src/laddr/llms.py`，使用方法如下：\n```python\nanthropic(model=..., temperature=...)\n```\n**参数说明**：\n- `model`: str | None\n- `temperature`: float | None"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`ToolRegistry.get` 有什么功能？"}, {"role": "assistant", "content": "`ToolRegistry.get` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/tooling.py`。\n**功能描述**：\nGet a tool by name or alias. Args: name: Tool name (canonical or alias) Returns: Tool instance or None if not found\n**函数签名**：\n```python\ndef get(self, name: str) -> Tool | None:\n```\n**参数**：\n- `self` (Any)\n- `name` (str): Tool name (canonical or alias)\n\n**返回值**：`Tool | None`"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `run_agent_cmd` 是做什么的？"}, {"role": "assistant", "content": "`run_agent_cmd` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/commands/run.py`。\n**功能描述**：\nRun a single agent locally using AgentRunner.\n**函数签名**：\n```python\ndef run_agent_cmd(agent_name: str, inputs_json: str):\n```\n**参数**：\n- `agent_name` (str)\n- `inputs_json` (str)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `_create_directories` 是做什么的？"}, {"role": "assistant", "content": "`_create_directories` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/commands/init.py`。\n**功能描述**：\nCreate project directory structure.\n**函数签名**：\n```python\ndef _create_directories(project_path: Path) -> None:\n```\n**参数**：\n- `project_path` (Path)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `groq` 函数？"}, {"role": "assistant", "content": "`groq` 位于 `lib/laddr/src/laddr/llms.py`，使用方法如下：\n```python\ngroq(model=..., temperature=...)\n```\n**参数说明**：\n- `model`: str | None - Model name (default: llama-3.3-70b-versatile)\n- `temperature`: float | None\n\n**功能简述**：Create a Groq LLM backend instance. Args: model: Model name (default: llama-3.3-70b-versatile) temperature: Generation temperature Example: llm = groq(model=\"llama-3.3-70b-versatile\", temperature=0.5)..."}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`get_tool_override` 有什么功能？"}, {"role": "assistant", "content": "`get_tool_override` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/core/system_tools.py`。\n**功能描述**：\nGet a tool override if it exists. Args: tool_name: Name of the tool to check Returns: The override function if registered, None otherwise\n**函数签名**：\n```python\ndef get_tool_override(tool_name: str) -> Callable | None:\n```\n**参数**：\n- `tool_name` (str): Name of the tool to check\n\n**返回值**：`Callable | None`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `run_dev` 函数？"}, {"role": "assistant", "content": "`run_dev` 位于 `lib/laddr/src/laddr/cli/commands/run.py`，使用方法如下：\n```python\nrun_dev(build=..., detach=...)\n```\n**参数说明**：\n- `build`: bool\n- `detach`: bool\n\n**功能简述**：Run the Laddr development environment. Starts all infrastructure services and agent workers: - PostgreSQL (internal observability database) - Redis (message bus) - API server - Agent workers - Dashboa..."}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `DatabaseService.get_job_traces` 是做什么的？"}, {"role": "assistant", "content": "`DatabaseService.get_job_traces` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/database.py`。\n**功能描述**：\nGet all traces for a job.\n**函数签名**：\n```python\ndef get_job_traces(self, job_id: str) -> list[dict]:\n```\n**参数**：\n- `self` (Any)\n- `job_id` (str)\n\n**返回值**：`list[dict]`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`InMemoryCache.clear` 方法在哪个文件里？"}, {"role": "assistant", "content": "`InMemoryCache.clear` 位于 `lib/laddr/src/laddr/core/cache.py`。"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `ResponseMessage.from_dict` 函数？"}, {"role": "assistant", "content": "`ResponseMessage.from_dict` 位于 `lib/laddr/src/laddr/core/message_bus.py`，使用方法如下：\n```python\nResponseMessage.from_dict(cls=..., data=...)\n```\n**参数说明**：\n- `cls`: Any\n- `data`: dict"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `check_docker_compose` 的作用。"}, {"role": "assistant", "content": "`check_docker_compose` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/utils/docker.py`。\n**功能描述**：\nCheck if Docker Compose is available. Returns: True if Docker Compose is available Raises: DockerNotFoundError: If Docker Compose is not found\n**函数签名**：\n```python\ndef check_docker_compose() -> bool:\n```\n**返回值**：`bool`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `MCPToolSource.__init__` 函数？"}, {"role": "assistant", "content": "`MCPToolSource.__init__` 位于 `lib/laddr/src/laddr/core/mcp_client.py`，使用方法如下：\n**参数说明**："}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `GeminiLLM` 是做什么的？"}, {"role": "assistant", "content": "`GeminiLLM` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/core/llm.py`。\n**功能描述**：\nGoogle Gemini LLM backend.\n**函数签名**：\n```python\nclass GeminiLLM:\n```"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `run_pipeline` 是做什么的？"}, {"role": "assistant", "content": "`run_pipeline` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/commands/run.py`。\n**功能描述**：\nRun a pipeline defined in a YAML file.\n**函数签名**：\n```python\ndef run_pipeline(pipeline_file: str):\n```\n**参数**：\n- `pipeline_file` (str)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `DatabaseService.get_trace` 函数？"}, {"role": "assistant", "content": "`DatabaseService.get_trace` 位于 `lib/laddr/src/laddr/core/database.py`，使用方法如下：\n```python\nDatabaseService.get_trace(trace_id=...)\n```\n**参数说明**：\n- `trace_id`: str\n\n**功能简述**：Get a single trace event by id with full payload...."}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`_list` 函数在哪个文件里？"}, {"role": "assistant", "content": "`_list` 位于 `lib/laddr/src/laddr/core/storage.py`。"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`print_panel` 函数在哪个文件里？"}, {"role": "assistant", "content": "`print_panel` 位于 `lib/laddr/src/laddr/cli/utils/logger.py`。"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`GroqLLM` 类在哪个文件里？"}, {"role": "assistant", "content": "`GroqLLM` 位于 `lib/laddr/src/laddr/core/llm.py`。"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`TaskDelegationTool` 有什么功能？"}, {"role": "assistant", "content": "`TaskDelegationTool` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/core/system_tools.py`。\n**功能描述**：\nTool for delegating tasks to other agents.\n**函数签名**：\n```python\nclass TaskDelegationTool:\n```"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`AgentRunner` 有什么功能？"}, {"role": "assistant", "content": "`AgentRunner` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/core/runtime_entry.py`。\n**功能描述**：\nHigh-level agent runner for executing agents and managing jobs. Provides: - run(): Execute agent with job tracking - replay(): Replay previous job - run_pipeline(): Orchestrate multi-agent workflow\n**函数签名**：\n```python\nclass AgentRunner:\n```"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `validate_project_directory` 的作用。"}, {"role": "assistant", "content": "`validate_project_directory` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/utils/config.py`。\n**功能描述**：\nCheck if a directory contains a valid Laddr project. Args: path: Directory path to check Returns: True if valid project directory\n**函数签名**：\n```python\ndef validate_project_directory(path: Path) -> bool:\n```\n**参数**：\n- `path` (Path): Directory path to check\n\n**返回值**：`bool`"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `TemplateRenderer` 的作用。"}, {"role": "assistant", "content": "`TemplateRenderer` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/cli/utils/templates.py`。\n**功能描述**：\nJinja2 template renderer for Laddr CLI.\n**函数签名**：\n```python\nclass TemplateRenderer:\n```"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `Agent.plan` 的作用。"}, {"role": "assistant", "content": "`Agent.plan` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/agent_runtime.py`。\n**功能描述**：\nCreate execution plan for a task. Default implementation: simple single-step plan. Subclasses should override for custom planning logic. Args: task: Task inputs Returns: List of steps, where each step is a dict with: - action: \"tool\" | \"delegate\" | \"llm\" | \"custom\" - Additional fields depending on action type\n**函数签名**：\n```python\ndef plan(self, task: dict) -> list[dict]:\n```\n**参数**：\n- `self` (Any)\n- `task` (dict): Task inputs\n\n**返回值**：`list[dict]`"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `Agent._tool_cache_key` 的作用。"}, {"role": "assistant", "content": "`Agent._tool_cache_key` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/agent_runtime.py`。\n**功能描述**：\nGenerate cache key for tool call.\n**函数签名**：\n```python\ndef _tool_cache_key(self, name: str, params: dict) -> str:\n```\n**参数**：\n- `self` (Any)\n- `name` (str)\n- `params` (dict)\n\n**返回值**：`str`"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `TemplateRenderer.__init__` 的作用。"}, {"role": "assistant", "content": "`TemplateRenderer.__init__` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/cli/utils/templates.py`。\n**功能描述**：\nInitialize template renderer. Args: templates_dir: Directory containing Jinja2 templates\n**函数签名**：\n```python\ndef __init__(self, templates_dir: Path):\n```\n**参数**：\n- `self` (Any)\n- `templates_dir` (Path): Directory containing Jinja2 templates\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `wrap_with_runtime_injection` 是做什么的？"}, {"role": "assistant", "content": "`wrap_with_runtime_injection` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/core/system_tools.py`。\n**功能描述**：\nWrap a custom system tool function to inject runtime parameters. Custom override functions can declare _message_bus, _artifact_storage, _agent parameters which will be automatically injected at call time.\n**函数签名**：\n```python\ndef wrap_with_runtime_injection(tool_func):\n```\n**参数**：\n- `tool_func` (Any)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `AgentRunner.replay` 函数？"}, {"role": "assistant", "content": "`AgentRunner.replay` 位于 `lib/laddr/src/laddr/core/runtime_entry.py`，使用方法如下：\n```python\nAgentRunner.replay(job_id=..., reexecute=...)\n```\n**参数说明**：\n- `job_id`: str - Job ID to replay\n- `reexecute`: bool\n\n**功能简述**：Replay a previous job. Args: job_id: Job ID to replay reexecute: If True, re-execute the job; if False, return stored result Returns: Job result..."}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`decorator` 函数在哪个文件里？"}, {"role": "assistant", "content": "`decorator` 位于 `lib/laddr/src/laddr/core/tooling.py`。"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `openai` 函数？"}, {"role": "assistant", "content": "`openai` 位于 `lib/laddr/src/laddr/llms.py`，使用方法如下：\n```python\nopenai(model=..., temperature=..., base_url=...)\n```\n**参数说明**：\n- `model`: str | None\n- `temperature`: float | None\n- `base_url`: str | None"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `DatabaseService.get_metrics` 的作用。"}, {"role": "assistant", "content": "`DatabaseService.get_metrics` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/database.py`。\n**功能描述**：\nGet aggregated metrics.\n**函数签名**：\n```python\ndef get_metrics(self) -> dict[str, Any]:\n```\n**参数**：\n- `self` (Any)\n\n**返回值**：`dict[str, Any]`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `ToolRegistry.register` 函数？"}, {"role": "assistant", "content": "`ToolRegistry.register` 位于 `lib/laddr/src/laddr/core/tooling.py`，使用方法如下：\n```python\nToolRegistry.register(tool_obj=..., name=..., aliases=...)\n```\n**参数说明**：\n- `tool_obj`: Tool | Callable - Tool instance or callable to register\n- `name`: str | None\n- `aliases`: list[str] | None\n\n**功能简述**：Register a tool with optional aliases. Args: tool_obj: Tool instance or callable to register name: Optional explicit name (overrides tool_obj.name) aliases: Optional list of alias names that resolve t..."}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `wrap_with_runtime_injection` 函数？"}, {"role": "assistant", "content": "`wrap_with_runtime_injection` 位于 `lib/laddr/src/laddr/core/system_tools.py`，使用方法如下：\n```python\nwrap_with_runtime_injection(tool_func=...)\n```\n**参数说明**：\n- `tool_func`: Any\n\n**功能简述**：Wrap a custom system tool function to inject runtime parameters. Custom override functions can declare _message_bus, _artifact_storage, _agent parameters which will be automatically injected at call t..."}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `ToolRegistry.list_names` 的作用。"}, {"role": "assistant", "content": "`ToolRegistry.list_names` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/tooling.py`。\n**功能描述**：\nList all canonical tool names (excludes aliases).\n**函数签名**：\n```python\ndef list_names(self) -> list[str]:\n```\n**参数**：\n- `self` (Any)\n\n**返回值**：`list[str]`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`create_tool_schema` 有什么功能？"}, {"role": "assistant", "content": "`create_tool_schema` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/core/tooling.py`。\n**功能描述**：\nCreate a JSON schema for a tool (for LLM function calling). Returns OpenAI-style function schema.\n**函数签名**：\n```python\ndef create_tool_schema(tool: Tool) -> dict[str, Any]:\n```\n**参数**：\n- `tool` (Tool)\n\n**返回值**：`dict[str, Any]`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`CacheBackend` 类在哪个文件里？"}, {"role": "assistant", "content": "`CacheBackend` 位于 `lib/laddr/src/laddr/core/config.py`。"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `AgentMemory.put` 函数？"}, {"role": "assistant", "content": "`AgentMemory.put` 位于 `lib/laddr/src/laddr/core/agent_runtime.py`，使用方法如下：\n```python\nAgentMemory.put(key=..., value=...)\n```\n**参数说明**：\n- `key`: str\n- `value`: Any\n\n**功能简述**：Store a memory entry...."}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`_generate_config_files` 有什么功能？"}, {"role": "assistant", "content": "`_generate_config_files` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/commands/init.py`。\n**功能描述**：\nGenerate configuration files.\n**函数签名**：\n```python\ndef _generate_config_files(project_path: Path, project_name: str) -> None:\n```\n**参数**：\n- `project_path` (Path)\n- `project_name` (str)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `DatabaseService.get_prompt_result` 是做什么的？"}, {"role": "assistant", "content": "`DatabaseService.get_prompt_result` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/database.py`。\n**功能描述**：\nGet prompt execution result.\n**函数签名**：\n```python\ndef get_prompt_result(self, prompt_id: str) -> dict | None:\n```\n**参数**：\n- `self` (Any)\n- `prompt_id` (str)\n\n**返回值**：`dict | None`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`QueueBackend` 有什么功能？"}, {"role": "assistant", "content": "`QueueBackend` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/core/config.py`。\n**功能描述**：\nProtocol for message queue backends.\n**函数签名**：\n```python\nclass QueueBackend(Protocol):\n```"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `load_agents` 是做什么的？"}, {"role": "assistant", "content": "`load_agents` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/core/config.py`。\n**功能描述**：\nLoad agents dynamically from 'agents.<name>.handler'. Supports two patterns: 1) @actor-decorated classes named <Name>Agent (instantiated without args) 2) Module-level Agent instances (any variable bound to laddr.core.agent_runtime.Agent)\n**函数签名**：\n```python\ndef load_agents() -> Dict[str, Any]:\n```\n**返回值**：`Dict[str, Any]`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `Agent._build_autonomous_system_prompt` 函数？"}, {"role": "assistant", "content": "`Agent._build_autonomous_system_prompt` 位于 `lib/laddr/src/laddr/core/agent_runtime.py`，使用方法如下：\n```python\nAgent._build_autonomous_system_prompt(available_tools=..., available_agents=..., can_delegate=...)\n```\n**参数说明**：\n- `available_tools`: list[str]\n- `available_agents`: list[dict]\n- `can_delegate`: bool\n\n**功能简述**：Build system prompt for autonomous agent...."}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `DatabaseBackend.memory_get` 函数？"}, {"role": "assistant", "content": "`DatabaseBackend.memory_get` 位于 `lib/laddr/src/laddr/core/config.py`，使用方法如下：\n```python\nDatabaseBackend.memory_get(agent_name=..., key=..., job_id=...)\n```\n**参数说明**：\n- `agent_name`: str\n- `key`: str\n- `job_id`: str | None"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`AgentRunner._discover_local_agents` 有什么功能？"}, {"role": "assistant", "content": "`AgentRunner._discover_local_agents` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/runtime_entry.py`。\n**功能描述**：\nDiscover local agents under the 'agents' package for inline execution.\n**函数签名**：\n```python\ndef _discover_local_agents(self, exclude: list[str] | None = None) -> list[str]:\n```\n**参数**：\n- `self` (Any)\n- `exclude` (list[str] | None)\n\n**返回值**：`list[str]`"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `InMemoryStorage.__init__` 是做什么的？"}, {"role": "assistant", "content": "`InMemoryStorage.__init__` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/storage.py`。\n**功能描述**：\nInitialize in-memory storage.\n**函数签名**：\n```python\ndef __init__(self):\n```\n**参数**：\n- `self` (Any)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `create_tool_schema` 函数？"}, {"role": "assistant", "content": "`create_tool_schema` 位于 `lib/laddr/src/laddr/core/tooling.py`，使用方法如下：\n```python\ncreate_tool_schema(tool=...)\n```\n**参数说明**：\n- `tool`: Tool\n\n**功能简述**：Create a JSON schema for a tool (for LLM function calling). Returns OpenAI-style function schema...."}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `check` 是做什么的？"}, {"role": "assistant", "content": "`check` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/commands/check.py`。\n**功能描述**：\nRun diagnostic checks for the Laddr runtime using the DiagnosticAgent.\n**函数签名**：\n```python\ndef check(output_path: str):\n```\n**参数**：\n- `output_path` (str)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`_generate_default_agent` 有什么功能？"}, {"role": "assistant", "content": "`_generate_default_agent` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/commands/init.py`。\n**功能描述**：\nGenerate default coordinator and researcher agents.\n**函数签名**：\n```python\ndef _generate_default_agent(project_path: Path) -> None:\n```\n**参数**：\n- `project_path` (Path)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `DatabaseService.__init__` 是做什么的？"}, {"role": "assistant", "content": "`DatabaseService.__init__` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/database.py`。\n**功能描述**：\nInitialize database service. Args: database_url: SQLAlchemy connection string e.g., \"postgresql://user:pass@host:5432/db\" or \"sqlite:///./laddr.db\" for local dev\n**函数签名**：\n```python\ndef __init__(self, database_url: str):\n```\n**参数**：\n- `self` (Any)\n- `database_url` (str): SQLAlchemy connection string\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`_generate_docker_setup` 函数在哪个文件里？"}, {"role": "assistant", "content": "`_generate_docker_setup` 位于 `lib/laddr/src/laddr/cli/commands/init.py`。"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `DatabaseBackend.append_trace` 函数？"}, {"role": "assistant", "content": "`DatabaseBackend.append_trace` 位于 `lib/laddr/src/laddr/core/config.py`，使用方法如下：\n```python\nDatabaseBackend.append_trace(job_id=..., agent_name=..., event_type=..., payload=...)\n```\n**参数说明**：\n- `job_id`: str\n- `agent_name`: str\n- `event_type`: str\n- `payload`: dict"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `bind_tools` 函数？"}, {"role": "assistant", "content": "`bind_tools` 位于 `lib/laddr/src/laddr/core/tooling.py`，使用方法如下：\n```python\nbind_tools(agent_instance=..., tools=...)\n```\n**参数说明**：\n- `agent_instance`: Any - Agent instance with .tools registry\n- `tools`: list[str | Callable]\n\n**功能简述**：Bind tools to an agent instance for explicit, readable tool registration. Supports: - String names: auto-import from agents.<agent>.tools.<name> - Callables: register directly - Decorated functions: e..."}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `ResponseMessage.to_dict` 函数？"}, {"role": "assistant", "content": "`ResponseMessage.to_dict` 位于 `lib/laddr/src/laddr/core/message_bus.py`，使用方法如下：\n**参数说明**："}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `InMemoryCache` 的作用。"}, {"role": "assistant", "content": "`InMemoryCache` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/core/cache.py`。\n**功能描述**：\nIn-memory cache for local dev and testing. Simple dict-based cache with optional TTL.\n**函数签名**：\n```python\nclass InMemoryCache:\n```"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `TaskMessage.to_dict` 函数？"}, {"role": "assistant", "content": "`TaskMessage.to_dict` 位于 `lib/laddr/src/laddr/core/message_bus.py`，使用方法如下：\n**参数说明**："}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `list_tool_overrides` 的作用。"}, {"role": "assistant", "content": "`list_tool_overrides` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/core/system_tools.py`。\n**功能描述**：\nList all registered tool overrides. Returns: Dict mapping tool names to their override function names\n**函数签名**：\n```python\ndef list_tool_overrides() -> dict[str, str]:\n```\n**返回值**：`dict[str, str]`"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `get_template_renderer` 是做什么的？"}, {"role": "assistant", "content": "`get_template_renderer` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/utils/templates.py`。\n**功能描述**：\nGet a configured template renderer. Returns: TemplateRenderer instance with CLI templates directory\n**函数签名**：\n```python\ndef get_template_renderer() -> TemplateRenderer:\n```\n**返回值**：`TemplateRenderer`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`InMemoryStorage` 有什么功能？"}, {"role": "assistant", "content": "`InMemoryStorage` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/core/storage.py`。\n**功能描述**：\nIn-memory storage backend for testing.\n**函数签名**：\n```python\nclass InMemoryStorage:\n```"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`ProjectConfigSchema.save_to_file` 有什么功能？"}, {"role": "assistant", "content": "`ProjectConfigSchema.save_to_file` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/cli/utils/config.py`。\n**功能描述**：\nSave project config to YAML file. Args: path: Path to laddr.yml Raises: InvalidConfigError: If save fails\n**函数签名**：\n```python\ndef save_to_file(self, path: Path) -> None:\n```\n**参数**：\n- `self` (Any)\n- `path` (Path): Path to laddr.yml\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`ProjectConfigSchema.load_from_file` 有什么功能？"}, {"role": "assistant", "content": "`ProjectConfigSchema.load_from_file` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/cli/utils/config.py`。\n**功能描述**：\nLoad project config from YAML file. Args: path: Path to laddr.yml Returns: Parsed project configuration Raises: InvalidConfigError: If config is invalid\n**函数签名**：\n```python\ndef load_from_file(cls, path: Path) -> ProjectConfigSchema:\n```\n**参数**：\n- `cls` (Any)\n- `path` (Path): Path to laddr.yml\n\n**返回值**：`ProjectConfigSchema`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`ollama` 有什么功能？"}, {"role": "assistant", "content": "`ollama` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/llms.py`。\n**功能描述**：\nCreate a local Ollama backend instance. Example: llm = ollama(model=\"gemma2:2b\", base_url=\"http://localhost:11434\")\n**函数签名**：\n```python\ndef ollama(model: str | None = None, temperature: float | None = None, base_url: str | None = None) -> _LLMWithDefaults:\n```\n**参数**：\n- `model` (str | None)\n- `temperature` (float | None)\n- `base_url` (str | None)\n\n**返回值**：`_LLMWithDefaults`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `validate_project_directory` 函数？"}, {"role": "assistant", "content": "`validate_project_directory` 位于 `lib/laddr/src/laddr/cli/utils/config.py`，使用方法如下：\n```python\nvalidate_project_directory(path=...)\n```\n**参数说明**：\n- `path`: Path - Directory path to check\n\n**功能简述**：Check if a directory contains a valid Laddr project. Args: path: Directory path to check Returns: True if valid project directory..."}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `override_system_tool` 函数？"}, {"role": "assistant", "content": "`override_system_tool` 位于 `lib/laddr/src/laddr/core/system_tools.py`，使用方法如下：\n```python\noverride_system_tool(tool_name=...)\n```\n**参数说明**：\n- `tool_name`: str - Name of the system tool to override (e.g., \"system_delegate_parallel\")\n\n**功能简述**：Decorator to override a system tool with a custom implementation. Use this decorator to replace built-in system tools (like system_delegate_parallel, system_split_document, etc.) with your own impleme..."}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`Agent._trace` 方法在哪个文件里？"}, {"role": "assistant", "content": "`Agent._trace` 位于 `lib/laddr/src/laddr/core/agent_runtime.py`。"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `BackendFactory.create_queue_backend` 函数？"}, {"role": "assistant", "content": "`BackendFactory.create_queue_backend` 位于 `lib/laddr/src/laddr/core/config.py`，使用方法如下：\n**参数说明**：\n\n**功能简述**：Create message queue backend based on config...."}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `run_prompt` 是做什么的？"}, {"role": "assistant", "content": "`run_prompt` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/commands/prompt.py`。\n**功能描述**：\nRun a prompt execution. Examples: laddr prompt run researcher --input query=\"AI trends\" laddr prompt run researcher --json '{\"query\": \"AI trends\"}' laddr prompt run researcher --json @inputs.json\n**函数签名**：\n```python\ndef run_prompt(prompt_name: str, inputs: tuple, json_input: str | None, wait: bool, timeout: int):\n```\n**参数**：\n- `prompt_name` (str)\n- `inputs` (tuple)\n- `json_input` (str | None)\n- `wait` (bool)\n- `timeout` (int)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `Agent._parse_autonomous_action_text` 的作用。"}, {"role": "assistant", "content": "`Agent._parse_autonomous_action_text` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/agent_runtime.py`。\n**功能描述**：\nParse legacy text format with ACTION:/AGENT:/TOOL_NAME:/... lines.\n**函数签名**：\n```python\ndef _parse_autonomous_action_text(self, response: str) -> dict:\n```\n**参数**：\n- `self` (Any)\n- `response` (str)\n\n**返回值**：`dict`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`Agent` 函数在哪个文件里？"}, {"role": "assistant", "content": "`Agent` 位于 `lib/laddr/src/laddr/__init__.py`。"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `LaddrError` 是做什么的？"}, {"role": "assistant", "content": "`LaddrError` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/cli/utils/errors.py`。\n**功能描述**：\nBase exception for all Laddr CLI errors.\n**函数签名**：\n```python\nclass LaddrError(Exception):\n```"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `DatabaseBackend.register_agent` 函数？"}, {"role": "assistant", "content": "`DatabaseBackend.register_agent` 位于 `lib/laddr/src/laddr/core/config.py`，使用方法如下：\n```python\nDatabaseBackend.register_agent(agent_name=..., metadata=...)\n```\n**参数说明**：\n- `agent_name`: str\n- `metadata`: dict"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `DockerNotFoundError` 的作用。"}, {"role": "assistant", "content": "`DockerNotFoundError` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/cli/utils/errors.py`。\n**功能描述**：\nRaised when Docker is not installed or not running.\n**函数签名**：\n```python\nclass DockerNotFoundError(LaddrError):\n```"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`run_dev` 有什么功能？"}, {"role": "assistant", "content": "`run_dev` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/commands/run.py`。\n**功能描述**：\nRun the Laddr development environment. Starts all infrastructure services and agent workers: - PostgreSQL (internal observability database) - Redis (message bus) - API server - Agent workers - Dashboard By default, shows live logs (like docker compose up). Use --detach/-d to run in background. Examples: laddr run dev              # Show logs laddr run dev --build      # Rebuild and show logs laddr run dev --detach     # Run in background\n**函数签名**：\n```python\ndef run_dev(build: bool, detach: bool):\n```\n**参数**：\n- `build` (bool)\n- `detach` (bool)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`HTTPLLM` 有什么功能？"}, {"role": "assistant", "content": "`HTTPLLM` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/core/llm.py`。\n**功能描述**：\nGeneric HTTP LLM adapter expecting a simple JSON API. It POSTs to endpoint with body: {\"prompt\": str, \"system\": str | null, \"params\": {...}} and expects a JSON response with {\"text\": str}.\n**函数签名**：\n```python\nclass HTTPLLM:\n```"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`FileGenerationError.__init__` 方法在哪个文件里？"}, {"role": "assistant", "content": "`FileGenerationError.__init__` 位于 `lib/laddr/src/laddr/cli/utils/errors.py`。"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`ArtifactStorageTool.__init__` 有什么功能？"}, {"role": "assistant", "content": "`ArtifactStorageTool.__init__` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/system_tools.py`。\n**功能描述**：\nInitialize artifact storage tool. Args: storage_backend: Storage backend (MinIO/S3)\n**函数签名**：\n```python\ndef __init__(self, storage_backend, default_bucket: str | None = None):\n```\n**参数**：\n- `self` (Any)\n- `storage_backend` (Any): Storage backend (MinIO/S3)\n- `default_bucket` (str | None)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `ParallelDelegationTool.split_document` 函数？"}, {"role": "assistant", "content": "`ParallelDelegationTool.split_document` 位于 `lib/laddr/src/laddr/core/system_tools.py`，使用方法如下：\n```python\nParallelDelegationTool.split_document(document=..., num_chunks=..., overlap=...)\n```\n**参数说明**：\n- `document`: str - The document text to split\n- `num_chunks`: int\n- `overlap`: int\n\n**功能简述**：Split a large document into smaller chunks for parallel processing. Use this before calling delegate_parallel to divide large documents into manageable sections that can be processed by multiple worke..."}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `DatabaseService.get_token_usage` 函数？"}, {"role": "assistant", "content": "`DatabaseService.get_token_usage` 位于 `lib/laddr/src/laddr/core/database.py`，使用方法如下：\n```python\nDatabaseService.get_token_usage(job_id=...)\n```\n**参数说明**：\n- `job_id`: str\n\n**功能简述**：Aggregate token usage for a job from llm_usage traces...."}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `ParallelDelegationTool.__init__` 是做什么的？"}, {"role": "assistant", "content": "`ParallelDelegationTool.__init__` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/system_tools.py`。\n**功能描述**：\nInitialize parallel delegation tool. Args: message_bus: Message queue backend for inter-agent communication artifact_storage: Optional storage backend for large payloads agent: Optional agent instance for job context propagation\n**函数签名**：\n```python\ndef __init__(self, message_bus, artifact_storage=None, agent=None):\n```\n**参数**：\n- `self` (Any)\n- `message_bus` (Any): Message queue backend for inter-agent communication\n- `artifact_storage` (Any)\n- `agent` (Any)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `compose_up` 是做什么的？"}, {"role": "assistant", "content": "`compose_up` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/utils/docker.py`。\n**功能描述**：\nStart Docker Compose services. Args: services: Optional list of specific services to start detach: Run in detached mode (default: True) build: Force rebuild images (default: False) scale: Optional dict of service: replicas for scaling Raises: DockerComposeError: If compose up fails\n**函数签名**：\n```python\ndef compose_up(\nservices: list[str] | None = None,\ndetach: bool = True,\nbuild: bool = False,\nscale: dict[str, int] | None = None,\n```\n**参数**：\n- `services` (list[str] | None): Optional list of specific services to start\n- `detach` (bool)\n- `build` (bool)\n- `scale` (dict[str, int] | None)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`BackendFactory.create_storage_backend` 方法在哪个文件里？"}, {"role": "assistant", "content": "`BackendFactory.create_storage_backend` 位于 `lib/laddr/src/laddr/core/config.py`。"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `WorkerRunner` 是做什么的？"}, {"role": "assistant", "content": "`WorkerRunner` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/core/runtime_entry.py`。\n**功能描述**：\nLightweight worker runner for a single agent instance. Consumes tasks from the message bus for the agent's name and publishes results.\n**函数签名**：\n```python\nclass WorkerRunner:\n```"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `TaskMessage` 是做什么的？"}, {"role": "assistant", "content": "`TaskMessage` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/core/message_bus.py`。\n**功能描述**：\nMessage sent to an agent's task queue.\n**函数签名**：\n```python\nclass TaskMessage:\n```"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`print_error` 函数在哪个文件里？"}, {"role": "assistant", "content": "`print_error` 位于 `lib/laddr/src/laddr/cli/utils/logger.py`。"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `Tool.validate_inputs` 的作用。"}, {"role": "assistant", "content": "`Tool.validate_inputs` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/tooling.py`。\n**功能描述**：\nValidate inputs against input_model if available. Returns validated inputs or raises ValidationError.\n**函数签名**：\n```python\ndef validate_inputs(self, inputs: dict[str, Any]) -> dict[str, Any]:\n```\n**参数**：\n- `self` (Any)\n- `inputs` (dict[str, Any])\n\n**返回值**：`dict[str, Any]`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`main` 函数在哪个文件里？"}, {"role": "assistant", "content": "`main` 位于 `lib/laddr/src/laddr/cli/main.py`。"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`_create_tool_file` 有什么功能？"}, {"role": "assistant", "content": "`_create_tool_file` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/commands/add.py`。\n**功能描述**：\nCreate tool file (project-level) and update agent configuration.\n**函数签名**：\n```python\ndef _create_tool_file(tool_name: str, agent_name: str, description: str) -> None:\n```\n**参数**：\n- `tool_name` (str)\n- `agent_name` (str)\n- `description` (str)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`Agent._discover_tool_overrides` 方法在哪个文件里？"}, {"role": "assistant", "content": "`Agent._discover_tool_overrides` 位于 `lib/laddr/src/laddr/core/agent_runtime.py`。"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`tool` 函数在哪个文件里？"}, {"role": "assistant", "content": "`tool` 位于 `lib/laddr/src/laddr/core/tooling.py`。"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`TaskMessage` 类在哪个文件里？"}, {"role": "assistant", "content": "`TaskMessage` 位于 `lib/laddr/src/laddr/core/message_bus.py`。"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`init` 函数在哪个文件里？"}, {"role": "assistant", "content": "`init` 位于 `lib/laddr/src/laddr/cli/commands/init.py`。"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `DatabaseService.memory_get` 是做什么的？"}, {"role": "assistant", "content": "`DatabaseService.memory_get` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/database.py`。\n**功能描述**：\nRetrieve a memory entry.\n**函数签名**：\n```python\ndef memory_get(self, agent_name: str, key: str, job_id: str | None = None) -> Any:\n```\n**参数**：\n- `self` (Any)\n- `agent_name` (str)\n- `key` (str)\n- `job_id` (str | None)\n\n**返回值**：`Any`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `Agent._register_system_tools` 函数？"}, {"role": "assistant", "content": "`Agent._register_system_tools` 位于 `lib/laddr/src/laddr/core/agent_runtime.py`，使用方法如下：\n**参数说明**：\n\n**功能简述**：Register built-in system tools for delegation and artifacts...."}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `_create_agent_files` 是做什么的？"}, {"role": "assistant", "content": "`_create_agent_files` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/commands/add.py`。\n**功能描述**：\nCreate agent files (flat layout) and update configuration.\n**函数签名**：\n```python\ndef _create_agent_files(\nagent_name: str,\nrole: str,\ngoal: str,\nbackstory: str,\n```\n**参数**：\n- `agent_name` (str)\n- `role` (str)\n- `goal` (str)\n- `backstory` (str)\n- `llm_provider` (str)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `Agent._register_system_tools` 的作用。"}, {"role": "assistant", "content": "`Agent._register_system_tools` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/agent_runtime.py`。\n**功能描述**：\nRegister built-in system tools for delegation and artifacts.\n**函数签名**：\n```python\ndef _register_system_tools(self):\n```\n**参数**：\n- `self` (Any)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 中，`write_file` 函数在哪个文件里？"}, {"role": "assistant", "content": "`write_file` 位于 `lib/laddr/src/laddr/cli/utils/templates.py`。"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`DatabaseService.create_tables` 有什么功能？"}, {"role": "assistant", "content": "`DatabaseService.create_tables` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/database.py`。\n**功能描述**：\nCreate all database tables if they don't exist.\n**函数签名**：\n```python\ndef create_tables(self):\n```\n**参数**：\n- `self` (Any)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `get_tool_override` 函数？"}, {"role": "assistant", "content": "`get_tool_override` 位于 `lib/laddr/src/laddr/core/system_tools.py`，使用方法如下：\n```python\nget_tool_override(tool_name=...)\n```\n**参数说明**：\n- `tool_name`: str - Name of the tool to check\n\n**功能简述**：Get a tool override if it exists. Args: tool_name: Name of the tool to check Returns: The override function if registered, None otherwise..."}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `AgentNotFoundError` 的作用。"}, {"role": "assistant", "content": "`AgentNotFoundError` 是 Laddr 项目中的一个 类，位于 `lib/laddr/src/laddr/cli/utils/errors.py`。\n**功能描述**：\nRaised when an agent doesn't exist.\n**函数签名**：\n```python\nclass AgentNotFoundError(LaddrError):\n```"}]}
{"conversations": [{"role": "user", "content": "简单介绍一下 Laddr 项目。"}, {"role": "assistant", "content": "Laddr 是一个 Python 项目。\n**核心目标**：\n<div align=\"center\">\n\n<img src=\"./Assets/laddr.svg\" alt=\"Laddr Logo\" width=\"360\" height=\"\">\n\n**Your framework for building scalable multi-agent systems**\n\n[![License: Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)\n[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)\n[![Docker](https://img.shields.io/badge/docker-optional-blue.svg)](https://www.docker.com/)\n[![FastAPI](https:/\n\n**主要技术栈**：bandit, black, boto3-stubs, build, click等。\n\n项目包含 279 个代码元素，主要由 67 个类和 212 个函数/方法构成。"}]}
{"conversations": [{"role": "user", "content": "在 Laddr 项目中，`groq` 有什么功能？"}, {"role": "assistant", "content": "`groq` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/llms.py`。\n**功能描述**：\nCreate a Groq LLM backend instance. Args: model: Model name (default: llama-3.3-70b-versatile) temperature: Generation temperature Example: llm = groq(model=\"llama-3.3-70b-versatile\", temperature=0.5)\n**函数签名**：\n```python\ndef groq(model: str | None = None, temperature: float | None = None) -> _LLMWithDefaults:\n```\n**参数**：\n- `model` (str | None): Model name (default: llama-3.3-70b-versatile)\n- `temperature` (float | None)\n\n**返回值**：`_LLMWithDefaults`"}]}
{"conversations": [{"role": "user", "content": "如何在 Laddr 中使用 `print_step` 函数？"}, {"role": "assistant", "content": "`print_step` 位于 `lib/laddr/src/laddr/cli/utils/logger.py`，使用方法如下：\n```python\nprint_step(step=..., description=...)\n```\n**参数说明**：\n- `step`: str - Step name/action\n- `description`: str\n\n**功能简述**：Print a step in a process with minimalistic style. Args: step: Step name/action description: Optional description..."}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `TaskDelegationTool.__init__` 的作用。"}, {"role": "assistant", "content": "`TaskDelegationTool.__init__` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/system_tools.py`。\n**功能描述**：\nInitialize task delegation tool. Args: message_bus: Message queue backend for inter-agent communication artifact_storage: Optional storage backend for large payloads agent: Optional agent instance for accessing current_job_id\n**函数签名**：\n```python\ndef __init__(self, message_bus, artifact_storage=None, agent=None):\n```\n**参数**：\n- `self` (Any)\n- `message_bus` (Any): Message queue backend for inter-agent communication\n- `artifact_storage` (Any)\n- `agent` (Any)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "请解释 Laddr 中 `Agent._discover_tool_overrides` 的作用。"}, {"role": "assistant", "content": "`Agent._discover_tool_overrides` 是 Laddr 项目中的一个 方法，位于 `lib/laddr/src/laddr/core/agent_runtime.py`。\n**功能描述**：\nAuto-discover and load tool override modules from the project. Searches common locations for tool override files: - ./tools/overrides/ - ./custom_tools/ - ./agent_tools/overrides/ When override modules are imported, the @override_system_tool decorators will automatically register the overrides.\n**函数签名**：\n```python\ndef _discover_tool_overrides(self):\n```\n**参数**：\n- `self` (Any)\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "Laddr 的 `print_info` 是做什么的？"}, {"role": "assistant", "content": "`print_info` 是 Laddr 项目中的一个 函数，位于 `lib/laddr/src/laddr/cli/utils/logger.py`。\n**功能描述**：\nPrint an info message. Args: message: Info message\n**函数签名**：\n```python\ndef print_info(message: str) -> None:\n```\n**参数**：\n- `message` (str): Info message\n\n**返回值**：`None`"}]}
{"conversations": [{"role": "user", "content": "Laddr 中有哪些核心类和函数？"}, {"role": "assistant", "content": "Laddr 的核心组件包括（基于复杂度和重要性）：\n\n- `LaddrConfig` (类)：位于 `lib/laddr/src/laddr/core/config.py` - Environment-based configuration for Laddr runtime. Supports pluggable backends f...\n- `Agent.__init__` (方法)：位于 `lib/laddr/src/laddr/core/agent_runtime.py` - Initialize agent. Args: config: Agent-specific configuration env_config: Environ...\n- `Agent` (类)：位于 `lib/laddr/src/laddr/core/agent_runtime.py` - Base Agent class with full runtime capabilities. Provides: - Planning and execut...\n- `DatabaseService` (类)：位于 `lib/laddr/src/laddr/core/database.py` - High-level database API. Provides methods for job management, tracing, memory, a...\n- `create_system_tools` (函数)：位于 `lib/laddr/src/laddr/core/system_tools.py` - Create system tools for task delegation and artifact management. This function c...\n- `Agent._parse_autonomous_action` (方法)：位于 `lib/laddr/src/laddr/core/agent_runtime.py` - Parse LLM response to extract action, preferring JSON format with text fallback....\n- `BackendFactory.create_llm_backend` (方法)：位于 `lib/laddr/src/laddr/core/config.py` - Create LLM backend based on config. If `override` is provided it takes precedenc...\n- `init` (函数)：位于 `lib/laddr/src/laddr/cli/commands/init.py` - Initialize a new Laddr project. Creates project structure with: - Configuration...\n- `KafkaBus` (类)：位于 `lib/laddr/src/laddr/core/message_bus.py` - Kafka-based message bus (experimental / enterprise option). Uses topics per agen...\n- `ToolRegistry.register` (方法)：位于 `lib/laddr/src/laddr/core/tooling.py` - Register a tool with optional aliases. Args: tool_obj: Tool instance or callable..."}]}