* feat(memory_recipes): introduce memory recipes module for source-type-specific ingestion
- Added a new `memory_recipes` module that includes functionality for handling various source types, such as email and chat, with dedicated recipes for ingestion.
- Implemented core types and the `Recipe` trait to facilitate the ingestion process, allowing for structured handling of raw content and metadata.
- Created specific recipes for email and chat, enhancing the ability to process and normalize content before storing it in memory.
- Updated the core controller registration to include new endpoints for memory recipes, enabling JSON-RPC interactions for ingesting content and listing available recipes.
- Enhanced task management by integrating task storage and query helpers, allowing for better tracking and management of action items extracted during ingestion.
These changes significantly improve the ingestion capabilities of the application, providing a robust framework for handling diverse content types.
* refactor: remove API key references from configuration and schema
- Eliminated the `api_key` field from various configuration schemas and related structures, including `Config`, `ModelSettingsPatch`, and `ComposioConfig`, to streamline the configuration process.
- Updated the handling of API keys in the application to rely solely on session JWTs, enhancing security and simplifying the authentication flow.
- Adjusted related documentation and comments to reflect the removal of the API key, ensuring clarity in the new authentication approach.
- Refactored multiple components and functions to remove dependencies on the API key, improving code maintainability and reducing complexity.
These changes significantly enhance the security posture of the application by removing reliance on static API keys and promoting the use of session-based authentication.
* chore: update .env.example and documentation for API key removal
- Removed references to `OPENHUMAN_API_KEY` from the `.env.example` file to reflect recent changes in the authentication approach.
- Updated documentation in `AGENTS.md` and `CLAUDE.md` to clarify that `OPENHUMAN_API_URL` now overrides `config.api_url`, ensuring consistency across configuration references.
- Bumped the version in `Cargo.lock` to 0.52.23 to align with the latest changes.
These updates enhance clarity in configuration management and documentation following the removal of static API keys.
* fix: address config pruning review comments
* feat(tests): add validation tests for SearchResponse deserialization
- Introduced new tests to ensure that the SearchResponse struct correctly rejects JSON inputs missing required fields: searchId, results, and costUsd.
- Updated DelegateTool instantiation to remove the unused fallback_credential parameter, simplifying the constructor and related tests.
These changes enhance the robustness of the SearchResponse handling and improve code clarity by removing unnecessary parameters.
* refactor: remove api_key params from provider factory signatures
The OpenHuman backend now only uses the app-session JWT for auth —
the api_key parameter was ignored (as _api_key) after the config
pruning. Drop it from the signatures entirely instead of leaving
dead None arguments at every call site.
Also removes the unused ChannelContext.api_key field.
* refactor: remove api_key/composio_key params from factory signatures
Every caller was passing None after the config pruning:
- create_embedding_provider / create_memory* — the api_key param
was only threaded to the openai / custom embedding branches, but
no caller has ever supplied a non-None value since the pruning.
Embeddings use an empty key; the param is gone.
- all_tools / all_tools_with_runtime — both composio_key and
composio_entity_id only fed the ComposioTool registration block,
which was already dead after the JWT migration. Drop both args
and the block; the modern path is all_composio_agent_tools via
build_composio_client(config).
* style: apply cargo fmt
* feat(event-bus): introduce typed request/response API for enhanced inter-module communication
- Added a typed request/response surface to the existing event bus, allowing modules to execute requests through a shared controller registry.
- Implemented `request_global` and `request_controller_global` functions for executing typed requests, enhancing the API's usability.
- Updated documentation to reflect the new capabilities and usage patterns for the event bus, including when to use the request API versus traditional event publishing.
- Added tests to validate the functionality of the new request/response features, ensuring robust integration with existing event bus operations.
* refactor(event-bus): restructure event bus module and update references
- Moved the event bus implementation from `src/openhuman/event_bus/` to `src/core/event_bus/`, establishing a clearer module hierarchy.
- Updated all references throughout the codebase to reflect the new location of the event bus, ensuring consistency and reducing confusion.
- Enhanced documentation to clarify the usage of the event bus and its core types, improving developer experience.
- Introduced new files for event handling, requests, and subscribers, streamlining the event bus functionality and making it more modular.
- Added tests to validate the new structure and ensure that the event bus operates correctly after the refactor.
* refactor(event-bus): enhance event bus with native request/response surface
- Updated the event bus to include a native, in-process typed request/response surface, allowing for zero serialization of Rust types and direct communication between modules.
- Replaced the previous request API with a more streamlined approach using `register_native_global` and `request_native_global` functions.
- Improved documentation to clarify the usage of the event bus, detailing when to use broadcast events versus native requests.
- Removed the old request/response implementation to simplify the event bus structure and enhance maintainability.
- Added examples and guidelines for registering and using native request handlers, improving developer experience and usability.
* feat(agent): introduce native request handlers for agentic turns
- Added a new `bus` module to encapsulate native event-bus handlers for the agent domain, including the `agent.run_turn` handler for executing agentic turns.
- Updated the event bus registration process to include the new agent handlers, allowing for direct in-process request/response communication without serialization.
- Refactored the channel message processing to dispatch agentic turns through the native bus, enhancing modularity and testability.
- Improved documentation to clarify the usage of the new agent handlers and their integration with the event bus.
- Added tests to validate the functionality of the new request handlers and ensure proper routing through the event bus.
* refactor(tests): implement global bus handler lock for channel dispatch tests
- Introduced a `use_real_agent_handler` function to manage the global bus handler lock during channel dispatch tests, ensuring exclusive access to the `agent.run_turn` handler.
- Updated multiple test files to utilize the new handler function, improving test reliability by preventing race conditions during concurrent test execution.
- Enhanced documentation to clarify the usage of the bus handler lock in tests that interact with the global native request registry.
* feat(tests): add integration tests for Discord channel dispatch
- Introduced a new test file `discord_integration.rs` to validate the end-to-end functionality of the Discord dispatch path within the channels module.
- Implemented tests to ensure proper handling of inbound messages, reaction capabilities, and conversation history management specific to Discord.
- Updated `mod.rs` to include the new Discord integration tests, enhancing overall test coverage for the channels module.
* feat(tests): add Telegram integration tests for channel dispatch
- Introduced new tests in `telegram_integration.rs` to validate the end-to-end functionality of the Telegram dispatch path within the channels module.
- Implemented tests to ensure proper handling of threaded inbound messages, automatic acknowledgment reactions, and response routing through the agent bus handler.
- Enhanced test coverage for Telegram, ensuring that the `supports_reactions()` capability is honored and that the dispatch pipeline operates correctly for both Telegram and Discord channels.
* feat(tests): add testing utilities for event bus stubbing
- Introduced a new `testing` module in the event bus to provide shared utilities for stubbing the global native bus registry.
- Implemented `mock_bus_stub` and `MockBusGuard` to facilitate safe installation and restoration of stub handlers in tests, preventing race conditions.
- Updated existing tests to utilize the new mocking utilities, enhancing test reliability and clarity in handling agent bus interactions.
- Improved documentation to guide users on using the new testing features effectively.
* style(event-bus): clean up formatting and remove unnecessary line breaks
- Removed trailing whitespace and unnecessary line breaks in the event bus module files to improve code readability and maintainability.
- Consolidated import statements and function definitions for a cleaner code structure across the event bus and agent modules.
* fix(memory): point conversations/bus.rs at crate::core::event_bus
Incoming `memory/conversations/bus.rs` from upstream/main still imports
from the old `openhuman::event_bus` path. This branch relocated the bus
to `core::event_bus`, so the merge left the import unresolved and the
crate failed to compile. Rewire both references (`use` + fully-qualified
`subscribe_global` call) to the canonical `crate::core::event_bus` path.
- Removed outdated workflows for lander deployment and PR creation from develop to main.
- Updated build workflow to trigger on push events.
- Renamed version bump workflow to indicate it's legacy.
- Simplified CLAUDE.md by removing unnecessary introductory text.
- Introduced AGENTS.md to outline project structure, build commands, coding style, testing guidelines, and commit/pull request practices.
- Included detailed sections on module organization and naming conventions to enhance developer onboarding and consistency.
