Something went wrong. Try again.
personal memory agent
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327# SPDX-License-Identifier: AGPL-3.0-only# Copyright (c) 2026 sol pbc
from __future__ import annotations
import inspectimport sysimport typesfrom types import SimpleNamespacefrom typing import Any
class FakeModel: def __init__(self, **kwargs: Any) -> None: self.__dict__.update(kwargs)
def model_dump(self, mode: str = "json") -> dict[str, Any]: del mode return {key: _dump(value) for key, value in self.__dict__.items()}
def _dump(value: Any) -> Any: if isinstance(value, SimpleNamespace): return {key: _dump(item) for key, item in vars(value).items()} if isinstance(value, FakeModel): return value.model_dump() if isinstance(value, list): return [_dump(item) for item in value] if isinstance(value, tuple): return [_dump(item) for item in value] if isinstance(value, dict): return {str(key): _dump(item) for key, item in value.items()} if isinstance(value, str | int | float | bool | type(None)): return value return repr(value)
class Action(FakeModel): pass
class Observation(FakeModel): @classmethod def from_text( cls, text: str, is_error: bool = False, **kwargs: Any, ) -> Observation: return cls(text=text, is_error=is_error, **kwargs)
class ToolExecutor: def __call__(self, action: Action, conversation: Any = None) -> Observation: raise NotImplementedError
class ToolDefinition: name = ""
def __init_subclass__(cls, **kwargs: Any) -> None: super().__init_subclass__(**kwargs) if "name" not in cls.__dict__: cls.name = cls.__name__.removesuffix("Tool").lower()
def __init__(self, **kwargs: Any) -> None: self.__dict__.update(kwargs) self.name = self.__class__.name
def __class_getitem__(cls, _item: Any) -> type[ToolDefinition]: return cls
@classmethod def create(cls, *args: Any, **kwargs: Any) -> list[Any]: del args, kwargs return []
def action_from_arguments(self, arguments: dict[str, Any]) -> Action: return self.action_type(**arguments)
def __call__(self, action: Action, conversation: Any = None) -> Observation: return self.executor(action, conversation)
class ToolAnnotations(FakeModel): pass
class FinishTool: @classmethod def create(cls, *args: Any, **kwargs: Any) -> list[Any]: del args, kwargs return [cls()]
class Tool(FakeModel): pass
_REGISTERED_TOOLS: dict[str, Any] = {}
def register_tool(name: str, factory: Any) -> None: _REGISTERED_TOOLS[name] = factory
class TokenUsage(FakeModel): prompt_tokens = 0 completion_tokens = 0 cache_read_tokens = 0 cache_write_tokens = 0 reasoning_tokens = 0 per_turn_token = 0
class Metrics(FakeModel): def __init__(self) -> None: super().__init__( accumulated_cost=0.0, accumulated_token_usage=TokenUsage(), token_usages=[], )
def _direct_generation_response(model: str) -> SimpleNamespace: message = SimpleNamespace( content=[SimpleNamespace(text="fake response")], thinking_blocks=[], reasoning_content=None, responses_reasoning_item=None, ) return SimpleNamespace( message=message, metrics=Metrics(), raw_response={ "model": model, "choices": [{"finish_reason": "stop"}], }, )
class LLM(FakeModel): instances: list[LLM] = []
def __init__(self, **kwargs: Any) -> None: super().__init__(**kwargs) self.metrics = Metrics() self.effective_max_input_tokens = None self.last_completion_messages = None self.last_completion_kwargs = None self.last_completion_merged_kwargs = None self.last_responses_messages = None self.last_responses_kwargs = None self.last_responses_merged_kwargs = None type(self).instances.append(self)
def completion(self, messages: Any, **kwargs: Any) -> SimpleNamespace: merged = dict(timeout=self.timeout, **kwargs) self.last_completion_messages = messages self.last_completion_kwargs = dict(kwargs) self.last_completion_merged_kwargs = merged return _direct_generation_response(self.model)
def responses(self, messages: Any, **kwargs: Any) -> SimpleNamespace: merged = {"timeout": self.timeout, **kwargs} self.last_responses_messages = messages self.last_responses_kwargs = dict(kwargs) self.last_responses_merged_kwargs = merged return _direct_generation_response(self.model)
async def acompletion(self, messages: Any, **kwargs: Any) -> SimpleNamespace: return self.completion(messages, **kwargs)
async def aresponses(self, messages: Any, **kwargs: Any) -> SimpleNamespace: return self.responses(messages, **kwargs)
class ImageContent(FakeModel): pass
class Message(FakeModel): pass
class TextContent(FakeModel): pass
class Agent(FakeModel): pass
class Conversation(FakeModel): arun_impl = None instances: list[Conversation] = []
def __init__(self, **kwargs: Any) -> None: super().__init__(**kwargs) self.messages: list[str] = [] self.paused = False self.interrupted = False self.closed = False self.state = SimpleNamespace(execution_status=None) type(self).instances.append(self)
def send_message(self, message: str) -> None: self.messages.append(message)
def pause(self) -> None: self.paused = True
def interrupt(self) -> None: self.interrupted = True self.state.execution_status = "paused"
def close(self) -> None: self.closed = True
async def arun(self) -> None: if type(self).arun_impl is None: return result = type(self).arun_impl(self) if inspect.isawaitable(result): await result
class ActionEvent(FakeModel): pass
class ObservationEvent(FakeModel): pass
class MessageEvent(FakeModel): pass
class AgentErrorEvent(FakeModel): pass
class ConversationErrorEvent(FakeModel): pass
def install_fake_openhands(monkeypatch: Any) -> types.SimpleNamespace: Conversation.instances = [] Conversation.arun_impl = None LLM.instances = [] _REGISTERED_TOOLS.clear()
root_mod = types.ModuleType("openhands") sdk_mod = types.ModuleType("openhands.sdk") event_mod = types.ModuleType("openhands.sdk.event") conversation_error_mod = types.ModuleType("openhands.sdk.event.conversation_error") llm_mod = types.ModuleType("openhands.sdk.llm") tool_mod = types.ModuleType("openhands.sdk.tool") schema_mod = types.ModuleType("openhands.sdk.tool.schema") builtins_mod = types.ModuleType("openhands.sdk.tool.builtins") finish_mod = types.ModuleType("openhands.sdk.tool.builtins.finish") registry_mod = types.ModuleType("openhands.sdk.tool.registry") spec_mod = types.ModuleType("openhands.sdk.tool.spec")
sdk_mod.LLM = LLM sdk_mod.Agent = Agent sdk_mod.Conversation = Conversation llm_mod.ImageContent = ImageContent llm_mod.Message = Message llm_mod.TextContent = TextContent event_mod.ActionEvent = ActionEvent event_mod.ObservationEvent = ObservationEvent event_mod.MessageEvent = MessageEvent event_mod.AgentErrorEvent = AgentErrorEvent conversation_error_mod.ConversationErrorEvent = ConversationErrorEvent tool_mod.ToolDefinition = ToolDefinition tool_mod.ToolExecutor = ToolExecutor tool_mod.ToolAnnotations = ToolAnnotations schema_mod.Action = Action schema_mod.Observation = Observation finish_mod.FinishTool = FinishTool registry_mod.register_tool = register_tool spec_mod.Tool = Tool
root_mod.sdk = sdk_mod sdk_mod.event = event_mod sdk_mod.llm = llm_mod sdk_mod.tool = tool_mod event_mod.conversation_error = conversation_error_mod tool_mod.schema = schema_mod tool_mod.builtins = builtins_mod tool_mod.registry = registry_mod tool_mod.spec = spec_mod builtins_mod.finish = finish_mod
modules = { "openhands": root_mod, "openhands.sdk": sdk_mod, "openhands.sdk.event": event_mod, "openhands.sdk.event.conversation_error": conversation_error_mod, "openhands.sdk.llm": llm_mod, "openhands.sdk.tool": tool_mod, "openhands.sdk.tool.schema": schema_mod, "openhands.sdk.tool.builtins": builtins_mod, "openhands.sdk.tool.builtins.finish": finish_mod, "openhands.sdk.tool.registry": registry_mod, "openhands.sdk.tool.spec": spec_mod, } for name, module in modules.items(): monkeypatch.setitem(sys.modules, name, module)
return types.SimpleNamespace( Action=Action, Observation=Observation, ActionEvent=ActionEvent, ObservationEvent=ObservationEvent, MessageEvent=MessageEvent, AgentErrorEvent=AgentErrorEvent, ConversationErrorEvent=ConversationErrorEvent, Conversation=Conversation, LLM=LLM, ImageContent=ImageContent, Message=Message, TextContent=TextContent, )