haiku.rag-slim 0.16.0__py3-none-any.whl → 0.24.0__py3-none-any.whl

haiku_rag_slim-0.24.0.dist-info/RECORD

@@ -0,0 +1,78 @@
+haiku/rag/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+haiku/rag/app.py,sha256=2qlhInl44ht6A91rGbelJ37try05_cClGBmuavfVzvs,35660
+haiku/rag/cli.py,sha256=o2eraDHEapSMMuV9rJbYwj58lW1Gm4WygKUMUXtU-js,17752
+haiku/rag/cli_chat.py,sha256=CFKqsI2Ppq-BM8VYl-MeiVDW79d06JiPO8lTFbJPeTY,19662
+haiku/rag/client.py,sha256=CVAJuLlYIKzcm_aVqCc-xSY4s5r01iUKz2rSyT7Nq0g,65286
+haiku/rag/logging.py,sha256=dm65AwADpcQsH5OAPtRA-4hsw0w5DK-sGOvzYkj6jzw,1720
+haiku/rag/mcp.py,sha256=0lkE76fKlqRLFy2Yrvw-NHepKfnjNKNbDTmPVeqWaeo,9219
+haiku/rag/monitor.py,sha256=KNN05YFwCXotgRTN6AMfOZLyqfLyfbrMMe5v8nVubAA,8005
+haiku/rag/utils.py,sha256=_wgx60F_IFqlMT2E9iL6qpHtdwIghCRwRL9Jy0G3xO8,14063
+haiku/rag/chunkers/__init__.py,sha256=V1eMI6bGEDOQxLj5hGE9LbJGQK0Vg8xU-_D3uI7Gwac,984
+haiku/rag/chunkers/base.py,sha256=LONA653zBZ9dkfY6WVNaDY56u5pZU4QL_Ei7MHOHBec,924
+haiku/rag/chunkers/docling_local.py,sha256=ycBV6YlKUPOqQM9FXs2n6oQ5KjEFKPDJJ8uI7fvC8tg,6469
+haiku/rag/chunkers/docling_serve.py,sha256=pOFSRXGc_pH19Qu67XcSQ4nIn_wWb0enXq_B0eaD3K0,6358
+haiku/rag/config/__init__.py,sha256=rDIHz0tRLgoBESPFfpf02826_2X11Cl5TKVtv4fHBIg,1780
+haiku/rag/config/loader.py,sha256=YX2sq2_sn5GLQlmnbxugmF46RK2sBVGYjEHsgSNHdZ0,1564
+haiku/rag/config/models.py,sha256=rQ0wJaxWcaCYhK4BFAMgKwsQHfnv_ikFI-8M1hmropc,6097
+haiku/rag/converters/__init__.py,sha256=w3YXOO0cw175CRXN4y5LseUXZjgh_gZmgMjK0jj4hlQ,1033
+haiku/rag/converters/base.py,sha256=PWPW2KmPqhOeHs6rFjeSKpz9l4lq0TwT6yVTyKt7fP0,1880
+haiku/rag/converters/docling_local.py,sha256=5qMpEVqje_GCSApezHCqd1X-rKgJX6LQfciQvUdowik,6830
+haiku/rag/converters/docling_serve.py,sha256=pWojTRTqqkeBhnP71INYo7_lu_OwJUcGpslF9yntAKg,8220
+haiku/rag/converters/text_utils.py,sha256=G_7YSSxlAYT9UNdxwFXrrxstKTsL2QAtDZ60V-v32wk,7016
+haiku/rag/embeddings/__init__.py,sha256=jFfLesylVjoZk3SWonUsmMnd_Qc1Xgxc30J5ttFGTRs,4896
+haiku/rag/embeddings/voyageai.py,sha256=5QtujhGT-kPh9HmALvxTj9Bqq0OXFlmZXfDlE2UQUWU,6029
+haiku/rag/graph/__init__.py,sha256=DJkmRj_MsoscV-dEtztRwf9kNUEa-5s174JlnfvNk_s,320
+haiku/rag/graph/agui/__init__.py,sha256=qjsGCNYgWGTTwjD0oIMomIkiKt_q_UeqmgZFaOfttpM,1472
+haiku/rag/graph/agui/cli_renderer.py,sha256=jK_FUj17y2ArBFGNAItiu3ItPWII5FxXeDn7FprZZxw,5188
+haiku/rag/graph/agui/emitter.py,sha256=aybeCL85fRuRArJ1woUQ0wF4FJlkskyHHvZKL_k5I40,12148
+haiku/rag/graph/agui/server.py,sha256=njBVWz7GbKb55c4R0BDOWVpOWVRxM7VIW8wvIXTA3x0,8511
+haiku/rag/graph/agui/state.py,sha256=LkuuAY9w32pc0kkXkLJvyNGC0JzhXn05IfIVZzCXAv0,965
+haiku/rag/graph/agui/stream.py,sha256=t2_Y5KCs-HQ-XCQ2J475JJjN7hvNJXylz_hyA_s_DY4,2654
+haiku/rag/graph/research/__init__.py,sha256=hLpyshx6yhTd7QHsg142PRAoSB2lZ8td1A5Vj9ArV_I,196
+haiku/rag/graph/research/dependencies.py,sha256=n8nbim6ZsicjAmBO7OzQHqIsmObYPdAQKFmubdRg9hM,1250
+haiku/rag/graph/research/graph.py,sha256=X5iJGfEBThAEklLwPu5P4mERLgH8Cpd-MPw_FTalowE,20622
+haiku/rag/graph/research/models.py,sha256=TnR6s1ITcFKUzzxWVfuFLBEhVmm6nIV9A2ch6x6TBqQ,4506
+haiku/rag/graph/research/prompts.py,sha256=Y_X6sf66wB0P9TV_86PB2zuBDi2e9zKdq24r1DLJZKA,5071
+haiku/rag/graph/research/state.py,sha256=nsOAwwqtgt8kCOisRbop9GpD2JDyhWtDI-wSJcTxEJo,3274
+haiku/rag/inspector/__init__.py,sha256=39qX_LMtypITucYi_9gdKarGRH2wG4vK0iAt208AKy8,285
+haiku/rag/inspector/app.py,sha256=HiCvBVLnDG4iwrop80ykYkWyNAzYgoH3voLPuVuGSh4,8075
+haiku/rag/inspector/widgets/__init__.py,sha256=XX2Ec-MOgJ9juzs0IfShkjFno_17V0ovpK8s37mqQNE,344
+haiku/rag/inspector/widgets/chunk_list.py,sha256=JJmGQ1emPsOWkwP5PjdCtquIZAfJmu4PxrTAdcAZ5pc,3391
+haiku/rag/inspector/widgets/context_modal.py,sha256=Ywx-eZRq6Qb1hN78Ni-JBamYeVfy8BHWOE91MWnv57s,2645
+haiku/rag/inspector/widgets/detail_view.py,sha256=w8h8WSAN4GpGYOq_stga1YhCQqSx2p-iFO4vLHaoPI4,5074
+haiku/rag/inspector/widgets/document_list.py,sha256=K5P0Y2qUl0mh-psUQzbJJXSitlZrHqtT9WOIcw7mABw,2853
+haiku/rag/inspector/widgets/info_modal.py,sha256=UJ_KHRVcPWD5FR9cr7De2tTIU-qMsCwCYm0xaHuFesM,7156
+haiku/rag/inspector/widgets/search_modal.py,sha256=dYAxCvwdKc3cHLjh4hI5ROQt0nS9mFLzz_1UPV9Shh0,6376
+haiku/rag/inspector/widgets/visual_modal.py,sha256=Pk_3cDIDHE_6_PBxV5MPtY9zhi9f7ODnhZNO4QJnjUQ,3959
+haiku/rag/providers/__init__.py,sha256=Tih4mcHM6bFe1R-fZvvb9KSVennxVX7mb44NrNERNQw,146
+haiku/rag/providers/docling_serve.py,sha256=cT1J3Xo-BW0_lZwHSNeL14wjCJ4TTf9s3H0qBkNkmN0,3834
+haiku/rag/qa/__init__.py,sha256=4E7wyeN6mxyJpKnNsO2Hr0aoK4LqSoaEUBK4sLU4QGs,1112
+haiku/rag/qa/agent.py,sha256=BOon9aRo-5Vs5yCKVSnY1slMiEvXmiaH8VTi0fwVHJk,2698
+haiku/rag/qa/prompts.py,sha256=Q6Pxf_obroiX6aWGvf9qjD__2KFy77_b_XrqCZpI8WQ,1403
+haiku/rag/reranking/__init__.py,sha256=03LKxmcd6Qt03o7yfNtEj1kDLKkmGZv9cQDQdohGm54,2223
+haiku/rag/reranking/base.py,sha256=nwrlGzNkdBg2WVBzPMsrvqGYQPmjwPrOvfPs9KyydVI,456
+haiku/rag/reranking/cohere.py,sha256=KntIQPIHDxa3WlFgx0ETvItirRVw_RnJehFA2ZHvLSE,1130
+haiku/rag/reranking/mxbai.py,sha256=XVIyMHTXHlDsgvml3J1uvm7wIggA2E-0E8ATt7p-PfY,1042
+haiku/rag/reranking/vllm.py,sha256=J-b9S0l3at9H_DwTZ0BkwVRgwVb-D62kunQyQBh2nRE,1459
+haiku/rag/reranking/zeroentropy.py,sha256=bT4_KQd8aksPiyX8wjqdMerPoME-223lCRb1BoxfYvY,1995
+haiku/rag/store/__init__.py,sha256=ixTDcjtFZ1MCqB9CIM1P9c9K-5mlc9uRtvD3ekZCn0E,159
+haiku/rag/store/engine.py,sha256=wcwmxmHBdO4vHXAPpsd3lOtFLL5O1qmycIp37zqhl7w,19129
+haiku/rag/store/exceptions.py,sha256=l7wxxI3CsXTkhRwYZSwH5nXhTTGO2jCg3mRqzG0pPzI,117
+haiku/rag/store/models/__init__.py,sha256=aUgKHt3XYVwqVmiAaW4z2u8sBOrP9mnqTZXxq0zHCHE,202
+haiku/rag/store/models/chunk.py,sha256=n9lCaEtY9B2S8pGW9PdX_c-SSmZvADY6Qprqu-u68Bc,6557
+haiku/rag/store/models/document.py,sha256=MGP2ai9wOQ53vWRTlw6FGAyg--GlVFBj8E0e828qEIE,2045
+haiku/rag/store/repositories/__init__.py,sha256=Olv5dLfBQINRV3HrsfUpjzkZ7Qm7goEYyMNykgo_DaY,291
+haiku/rag/store/repositories/chunk.py,sha256=htGEM5te7ToKQugtz1RzJPP8W-8SY7HEIo-iug834c4,16757
+haiku/rag/store/repositories/document.py,sha256=SsxwdcPvrRNOvJJadxazYn5GyV8pvm4-On8NnodTizY,6588
+haiku/rag/store/repositories/settings.py,sha256=lmk6Fk0abmbl2h3xNSGOscCpi6Y7GzYWzpzMIfEuFmk,6015
+haiku/rag/store/upgrades/__init__.py,sha256=or5dxhgVOCHt-w0R5NnTPWmrlDVVPMrLnZ9vaiAedeg,2589
+haiku/rag/store/upgrades/v0_10_1.py,sha256=fzLNz2nQO7BR25x_H6vz20Uyo4MZjhbz3Kz22sYgaAI,1979
+haiku/rag/store/upgrades/v0_19_6.py,sha256=5k__79mdn7u0UmlaGN7w2t74uVhnmScsFz0zCbnoPAU,1907
+haiku/rag/store/upgrades/v0_20_0.py,sha256=yFkZzOh59WSfcsTUsBVqFu-FGBsBvwGP_Y3Dn4BLh04,2267
+haiku/rag/store/upgrades/v0_23_1.py,sha256=ZuMuIZWWnC7_Rq63QB88fTIBbo121JAFjBrjv1wVpyk,2897
+haiku/rag/store/upgrades/v0_9_3.py,sha256=5zsOCeMaB5tHhx5AR8wGtCJGqqzA944sqYzDUPvYa4c,3382
+haiku_rag_slim-0.24.0.dist-info/METADATA,sha256=XZLY786eWEZjVaoUi_90r_1JqnRA4kLFx6I8YZHLhmw,4384
+haiku_rag_slim-0.24.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+haiku_rag_slim-0.24.0.dist-info/entry_points.txt,sha256=G1U3nAkNd5YDYd4v0tuYFbriz0i-JheCsFuT9kIoGCI,48
+haiku_rag_slim-0.24.0.dist-info/licenses/LICENSE,sha256=eXZrWjSk9PwYFNK9yUczl3oPl95Z4V9UXH7bPN46iPo,1065
+haiku_rag_slim-0.24.0.dist-info/RECORD,,

{haiku_rag_slim-0.16.0.dist-info → haiku_rag_slim-0.24.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

haiku/rag/chunker.py

@@ -1,65 +0,0 @@
-from typing import ClassVar
-
-import tiktoken
-from docling_core.transforms.chunker.tokenizer.openai import OpenAITokenizer
-from docling_core.types.doc.document import DoclingDocument
-
-from haiku.rag.config import Config
-
-# Check if docling is available
-try:
-    import docling  # noqa: F401
-
-    DOCLING_AVAILABLE = True
-except ImportError:
-    DOCLING_AVAILABLE = False
-
-
-class Chunker:
-    """A class that chunks text into smaller pieces for embedding and retrieval.
-
-    Uses docling's structure-aware chunking to create semantically meaningful chunks
-    that respect document boundaries.
-
-    Args:
-        chunk_size: The maximum size of a chunk in tokens.
-    """
-
-    encoder: ClassVar[tiktoken.Encoding] = tiktoken.encoding_for_model("gpt-4o")
-
-    def __init__(
-        self,
-        chunk_size: int = Config.processing.chunk_size,
-    ):
-        if not DOCLING_AVAILABLE:
-            raise ImportError(
-                "Docling is required for chunking. "
-                "Install with: pip install haiku.rag-slim[docling]"
-            )
-        from docling.chunking import HybridChunker  # type: ignore
-
-        self.chunk_size = chunk_size
-        tokenizer = OpenAITokenizer(
-            tokenizer=tiktoken.encoding_for_model("gpt-4o"), max_tokens=chunk_size
-        )
-
-        self.chunker = HybridChunker(tokenizer=tokenizer)  # type: ignore
-
-    async def chunk(self, document: DoclingDocument) -> list[str]:
-        """Split the document into chunks using docling's structure-aware chunking.
-
-        Args:
-            document: The DoclingDocument to be split into chunks.
-
-        Returns:
-            A list of text chunks with semantic boundaries.
-        """
-        if document is None:
-            return []
-
-        # Chunk using docling's hybrid chunker
-        chunks = list(self.chunker.chunk(document))
-        return [self.chunker.contextualize(chunk) for chunk in chunks]
-
-
-chunker = Chunker()

haiku/rag/embeddings/base.py

@@ -1,25 +0,0 @@
-from typing import overload
-
-from haiku.rag.config import AppConfig, Config
-
-
-class EmbedderBase:
-    _model: str = Config.embeddings.model
-    _vector_dim: int = Config.embeddings.vector_dim
-    _config: AppConfig = Config
-
-    def __init__(self, model: str, vector_dim: int, config: AppConfig = Config):
-        self._model = model
-        self._vector_dim = vector_dim
-        self._config = config
-
-    @overload
-    async def embed(self, text: str) -> list[float]: ...
-
-    @overload
-    async def embed(self, text: list[str]) -> list[list[float]]: ...
-
-    async def embed(self, text: str | list[str]) -> list[float] | list[list[float]]:
-        raise NotImplementedError(
-            "Embedder is an abstract class. Please implement the embed method in a subclass."
-        )

haiku/rag/embeddings/ollama.py

@@ -1,28 +0,0 @@
-from typing import overload
-
-from openai import AsyncOpenAI
-
-from haiku.rag.embeddings.base import EmbedderBase
-
-
-class Embedder(EmbedderBase):
-    @overload
-    async def embed(self, text: str) -> list[float]: ...
-
-    @overload
-    async def embed(self, text: list[str]) -> list[list[float]]: ...
-
-    async def embed(self, text: str | list[str]) -> list[float] | list[list[float]]:
-        client = AsyncOpenAI(
-            base_url=f"{self._config.providers.ollama.base_url}/v1", api_key="dummy"
-        )
-        if not text:
-            return []
-        response = await client.embeddings.create(
-            model=self._model,
-            input=text,
-        )
-        if isinstance(text, str):
-            return response.data[0].embedding
-        else:
-            return [item.embedding for item in response.data]

haiku/rag/embeddings/openai.py

@@ -1,26 +0,0 @@
-from typing import overload
-
-from openai import AsyncOpenAI
-
-from haiku.rag.embeddings.base import EmbedderBase
-
-
-class Embedder(EmbedderBase):
-    @overload
-    async def embed(self, text: str) -> list[float]: ...
-
-    @overload
-    async def embed(self, text: list[str]) -> list[list[float]]: ...
-
-    async def embed(self, text: str | list[str]) -> list[float] | list[list[float]]:
-        client = AsyncOpenAI()
-        if not text:
-            return []
-        response = await client.embeddings.create(
-            model=self._model,
-            input=text,
-        )
-        if isinstance(text, str):
-            return response.data[0].embedding
-        else:
-            return [item.embedding for item in response.data]

haiku/rag/embeddings/vllm.py

@@ -1,29 +0,0 @@
-from typing import overload
-
-from openai import AsyncOpenAI
-
-from haiku.rag.embeddings.base import EmbedderBase
-
-
-class Embedder(EmbedderBase):
-    @overload
-    async def embed(self, text: str) -> list[float]: ...
-
-    @overload
-    async def embed(self, text: list[str]) -> list[list[float]]: ...
-
-    async def embed(self, text: str | list[str]) -> list[float] | list[list[float]]:
-        client = AsyncOpenAI(
-            base_url=f"{self._config.providers.vllm.embeddings_base_url}/v1",
-            api_key="dummy",
-        )
-        if not text:
-            return []
-        response = await client.embeddings.create(
-            model=self._model,
-            input=text,
-        )
-        if isinstance(text, str):
-            return response.data[0].embedding
-        else:
-            return [item.embedding for item in response.data]

haiku/rag/graph/agui/events.py

@@ -1,254 +0,0 @@
-"""Generic AG-UI event creation utilities for any graph."""
-
-from typing import Any
-from uuid import uuid4
-
-from pydantic import BaseModel
-
-from haiku.rag.graph.agui.state import compute_state_delta
-
-# Type aliases for AG-UI events (actual types from ag_ui.core will be used at runtime)
-AGUIEvent = dict[str, Any]
-
-
-def emit_run_started(
-    thread_id: str, run_id: str, input_data: str | None = None
-) -> dict[str, Any]:
-    """Create a RunStarted event.
-
-    Args:
-        thread_id: Unique identifier for the conversation thread
-        run_id: Unique identifier for this run
-        input_data: Optional input that started the run
-
-    Returns:
-        RunStarted event dict
-    """
-    event: dict[str, Any] = {
-        "type": "RUN_STARTED",
-        "threadId": thread_id,
-        "runId": run_id,
-    }
-    if input_data:
-        event["input"] = input_data
-    return event
-
-
-def emit_run_finished(thread_id: str, run_id: str, result: Any) -> dict[str, Any]:
-    """Create a RunFinished event.
-
-    Args:
-        thread_id: Unique identifier for the conversation thread
-        run_id: Unique identifier for this run
-        result: The final result of the run
-
-    Returns:
-        RunFinished event dict
-    """
-    # Convert result to dict if it's a Pydantic model
-    if hasattr(result, "model_dump"):
-        result = result.model_dump()
-
-    return {
-        "type": "RUN_FINISHED",
-        "threadId": thread_id,
-        "runId": run_id,
-        "result": result,
-    }
-
-
-def emit_run_error(message: str, code: str | None = None) -> dict[str, Any]:
-    """Create a RunError event.
-
-    Args:
-        message: Error message
-        code: Optional error code
-
-    Returns:
-        RunError event dict
-    """
-    event: dict[str, Any] = {
-        "type": "RUN_ERROR",
-        "message": message,
-    }
-    if code:
-        event["code"] = code
-    return event
-
-
-def emit_step_started(step_name: str) -> dict[str, Any]:
-    """Create a StepStarted event.
-
-    Args:
-        step_name: Name of the step being started
-
-    Returns:
-        StepStarted event dict
-    """
-    return {
-        "type": "STEP_STARTED",
-        "stepName": step_name,
-    }
-
-
-def emit_step_finished(step_name: str) -> dict[str, Any]:
-    """Create a StepFinished event.
-
-    Args:
-        step_name: Name of the step that finished
-
-    Returns:
-        StepFinished event dict
-    """
-    return {
-        "type": "STEP_FINISHED",
-        "stepName": step_name,
-    }
-
-
-def emit_text_message(content: str, role: str = "assistant") -> dict[str, Any]:
-    """Create a TextMessageChunk event (convenience wrapper).
-
-    This creates a complete text message in one event.
-
-    Args:
-        content: The message content
-        role: The role of the sender (default: assistant)
-
-    Returns:
-        TextMessageChunk event dict
-    """
-    message_id = str(uuid4())
-    return {
-        "type": "TEXT_MESSAGE_CHUNK",
-        "messageId": message_id,
-        "role": role,
-        "delta": content,
-    }
-
-
-def emit_text_message_start(message_id: str, role: str = "assistant") -> dict[str, Any]:
-    """Create a TextMessageStart event.
-
-    Args:
-        message_id: Unique identifier for this message
-        role: The role of the sender
-
-    Returns:
-        TextMessageStart event dict
-    """
-    return {
-        "type": "TEXT_MESSAGE_START",
-        "messageId": message_id,
-        "role": role,
-    }
-
-
-def emit_text_message_content(message_id: str, delta: str) -> dict[str, Any]:
-    """Create a TextMessageContent event.
-
-    Args:
-        message_id: Identifier for the message being streamed
-        delta: Content chunk to append
-
-    Returns:
-        TextMessageContent event dict
-    """
-    return {
-        "type": "TEXT_MESSAGE_CONTENT",
-        "messageId": message_id,
-        "delta": delta,
-    }
-
-
-def emit_text_message_end(message_id: str) -> dict[str, Any]:
-    """Create a TextMessageEnd event.
-
-    Args:
-        message_id: Identifier for the message being completed
-
-    Returns:
-        TextMessageEnd event dict
-    """
-    return {
-        "type": "TEXT_MESSAGE_END",
-        "messageId": message_id,
-    }
-
-
-def emit_state_snapshot(state: BaseModel) -> dict[str, Any]:
-    """Create a StateSnapshot event.
-
-    Args:
-        state: The complete state to snapshot (any Pydantic BaseModel)
-
-    Returns:
-        StateSnapshot event dict
-    """
-    return {
-        "type": "STATE_SNAPSHOT",
-        "snapshot": state.model_dump(),
-    }
-
-
-def emit_state_delta(old_state: BaseModel, new_state: BaseModel) -> dict[str, Any]:
-    """Create a StateDelta event with JSON Patch operations.
-
-    Args:
-        old_state: Previous state (any Pydantic BaseModel)
-        new_state: Current state (same type as old_state)
-
-    Returns:
-        StateDelta event dict
-    """
-    delta = compute_state_delta(old_state, new_state)
-    return {
-        "type": "STATE_DELTA",
-        "delta": delta,
-    }
-
-
-def emit_activity(
-    message_id: str,
-    activity_type: str,
-    content: str,
-) -> dict[str, Any]:
-    """Create an ActivitySnapshot event.
-
-    Args:
-        message_id: Message ID to associate activity with (required)
-        activity_type: Type of activity (e.g., "planning", "searching")
-        content: Description of the activity
-
-    Returns:
-        ActivitySnapshot event dict
-    """
-    return {
-        "type": "ACTIVITY_SNAPSHOT",
-        "messageId": message_id,
-        "activityType": activity_type,
-        "content": content,
-    }
-
-
-def emit_activity_delta(
-    message_id: str,
-    activity_type: str,
-    patch: list[dict[str, Any]],
-) -> dict[str, Any]:
-    """Create an ActivityDelta event with JSON Patch operations.
-
-    Args:
-        message_id: Message ID of the activity being updated
-        activity_type: Type of activity being updated
-        patch: JSON Patch operations to apply
-
-    Returns:
-        ActivityDelta event dict
-    """
-    return {
-        "type": "ACTIVITY_DELTA",
-        "messageId": message_id,
-        "activityType": activity_type,
-        "patch": patch,
-    }

haiku/rag/graph/common/__init__.py

@@ -1,5 +0,0 @@
-"""Common utilities for graph implementations."""
-
-from haiku.rag.graph.common.utils import get_model
-
-__all__ = ["get_model"]

haiku/rag/graph/common/models.py

@@ -1,42 +0,0 @@
-"""Common models used across different graph implementations."""
-
-from pydantic import BaseModel, Field, field_validator
-
-
-class ResearchPlan(BaseModel):
-    """A structured research plan with sub-questions to explore."""
-
-    sub_questions: list[str] = Field(
-        ...,
-        description="Specific questions to research, phrased as complete questions",
-    )
-
-    @field_validator("sub_questions")
-    @classmethod
-    def validate_sub_questions(cls, v: list[str]) -> list[str]:
-        if len(v) < 1:
-            raise ValueError("Must have at least 1 sub-question")
-        if len(v) > 12:
-            raise ValueError("Cannot have more than 12 sub-questions")
-        return v
-
-
-class SearchAnswer(BaseModel):
-    """Answer from a search operation with sources."""
-
-    query: str = Field(..., description="The question that was answered")
-    answer: str = Field(..., description="The comprehensive answer to the question")
-    context: list[str] = Field(
-        default_factory=list,
-        description="Relevant snippets that directly support the answer",
-    )
-    sources: list[str] = Field(
-        default_factory=list,
-        description="Source URIs or titles that contributed to this answer",
-    )
-    confidence: float = Field(
-        default=1.0,
-        description="Confidence score for this answer (0-1)",
-        ge=0.0,
-        le=1.0,
-    )