adk-chatkit 0.0.1__tar.gz

adk_chatkit-0.0.1/.gitignore

@@ -0,0 +1,210 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+.env
+node_modules
+chatkit.db

adk_chatkit-0.0.1/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: adk-chatkit
+Version: 0.0.1
+Summary: Google ADK with openai chatkit
+Project-URL: repository, https://github.com/ksachdeva/adk-chatkit
+Author: Sachdeva, Kapil
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Requires-Dist: openai-chatkit>=1.0.2

adk_chatkit-0.0.1/pyproject.toml

@@ -0,0 +1,31 @@
+[project]
+name = "adk-chatkit"
+version = "0.0.1"
+description = "Google ADK with openai chatkit"
+readme = "README.md"
+authors = [
+    { name = "Sachdeva, Kapil"}
+]
+requires-python = ">=3.11"
+dependencies = [
+    "openai-chatkit>=1.0.2",
+]
+
+classifiers = [
+  "Intended Audience :: Developers",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Operating System :: OS Independent",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+  "License :: OSI Approved :: Apache Software License",
+]
+
+[project.urls]
+repository = "https://github.com/ksachdeva/adk-chatkit"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

adk_chatkit-0.0.1/src/adk_chatkit/__about__.py

@@ -0,0 +1,3 @@
+__author__ = "Kapil Sachdeva"
+__application__ = "adk-chatkit"
+__version__ = "0.0.1"

adk_chatkit-0.0.1/src/adk_chatkit/__init__.py

@@ -0,0 +1,20 @@
+from .__about__ import __application__, __author__, __version__
+from ._callbacks import remove_widgets_and_client_tool_calls
+from ._client_tool_call import ClientToolCallState, add_client_tool_call_to_tool_response
+from ._context import ADKContext
+from ._response import stream_agent_response
+from ._store import ADKStore
+from ._widgets import add_widget_to_tool_response
+
+__all__ = [
+    "__version__",
+    "__application__",
+    "__author__",
+    "ADKContext",
+    "ADKStore",
+    "stream_agent_response",
+    "ClientToolCallState",
+    "add_client_tool_call_to_tool_response",
+    "remove_widgets_and_client_tool_calls",
+    "add_widget_to_tool_response",
+]

adk_chatkit-0.0.1/src/adk_chatkit/_callbacks.py

@@ -0,0 +1,21 @@
+from google.adk.agents.callback_context import CallbackContext
+from google.adk.models.llm_request import LlmRequest
+from google.adk.models.llm_response import LlmResponse
+
+from ._constants import CLIENT_TOOL_KEY_IN_TOOL_RESPONSE, WIDGET_KEY_IN_TOOL_RESPONSE
+
+
+def remove_widgets_and_client_tool_calls(
+    callback_context: CallbackContext, llm_request: LlmRequest
+) -> LlmResponse | None:
+    for c in llm_request.contents:
+        if c.parts is None:
+            continue
+        for p in c.parts:
+            if not p.function_response:
+                continue
+            if p.function_response.response:
+                p.function_response.response.pop(WIDGET_KEY_IN_TOOL_RESPONSE, None)
+                p.function_response.response.pop(CLIENT_TOOL_KEY_IN_TOOL_RESPONSE, None)
+
+    return None

adk_chatkit-0.0.1/src/adk_chatkit/_client_tool_call.py

@@ -0,0 +1,47 @@
+from typing import Any, Literal
+from uuid import uuid4
+
+from google.adk.tools import ToolContext
+from pydantic import BaseModel, Field
+
+from ._constants import CHATKIT_THREAD_METADTA_KEY, CLIENT_TOOL_KEY_IN_TOOL_RESPONSE
+from ._thread_utils import (
+    add_client_tool_status,
+    serialize_thread_metadata,
+)
+
+
+class ClientToolCallState(BaseModel):
+    """
+    Returned from tool methods to indicate a client-side tool call.
+    """
+
+    id: str = Field(default_factory=lambda: uuid4().hex)
+
+    name: str
+    arguments: dict[str, Any]
+    status: Literal["pending", "completed"] = "pending"
+
+
+def add_client_tool_call_to_tool_response(
+    response: dict[str, Any],
+    client_tool_call: ClientToolCallState,
+    tool_context: ToolContext,
+) -> None:
+    """Add a client tool call to a tool response dictionary.
+
+    Args:
+        response: The tool response dictionary to modify.
+        client_tool_call: The client tool call state to add.
+    """
+
+    thread_metadata = add_client_tool_status(
+        tool_context.state,
+        client_tool_call.id,
+        client_tool_call.status,
+    )
+
+    # update the state
+    tool_context.state[CHATKIT_THREAD_METADTA_KEY] = serialize_thread_metadata(thread_metadata)
+
+    response[CLIENT_TOOL_KEY_IN_TOOL_RESPONSE] = client_tool_call

adk_chatkit-0.0.1/src/adk_chatkit/_constants.py

@@ -0,0 +1,5 @@
+from typing import Final
+
+WIDGET_KEY_IN_TOOL_RESPONSE: Final[str] = "adk-widget"
+CLIENT_TOOL_KEY_IN_TOOL_RESPONSE: Final[str] = "adk-client-tool"
+CHATKIT_THREAD_METADTA_KEY: Final[str] = "adk-chatkit-thread-metadata"

adk_chatkit-0.0.1/src/adk_chatkit/_context.py

@@ -0,0 +1,6 @@
+from typing import TypedDict
+
+
+class ADKContext(TypedDict):
+    app_name: str
+    user_id: str

adk_chatkit-0.0.1/src/adk_chatkit/_response.py

@@ -0,0 +1,118 @@
+import uuid
+from collections.abc import AsyncGenerator, AsyncIterator
+from datetime import datetime
+
+from chatkit.types import (
+    AssistantMessageContent,
+    AssistantMessageContentPartAdded,
+    AssistantMessageContentPartDone,
+    AssistantMessageContentPartTextDelta,
+    AssistantMessageItem,
+    ClientToolCallItem,
+    ThreadItemAddedEvent,
+    ThreadItemDoneEvent,
+    ThreadItemUpdated,
+    ThreadMetadata,
+    ThreadStreamEvent,
+    WidgetItem,
+)
+from google.adk.events import Event
+
+from ._client_tool_call import ClientToolCallState
+from ._constants import CLIENT_TOOL_KEY_IN_TOOL_RESPONSE, WIDGET_KEY_IN_TOOL_RESPONSE
+
+
+async def stream_agent_response(
+    thread: ThreadMetadata,
+    adk_response: AsyncGenerator[Event, None],
+) -> AsyncIterator[ThreadStreamEvent]:
+    if adk_response is None:
+        return
+
+    response_id = str(uuid.uuid4())
+
+    content_index = 0
+    async for event in adk_response:
+        if event.content is None:
+            # we need to throw item added event first
+            yield ThreadItemAddedEvent(
+                item=AssistantMessageItem(
+                    id=response_id,
+                    content=[],
+                    thread_id=thread.id,
+                    created_at=datetime.fromtimestamp(event.timestamp),
+                )
+            )
+
+            # and also yield an empty part added event
+            yield ThreadItemUpdated(
+                item_id=response_id,
+                update=AssistantMessageContentPartAdded(
+                    content_index=content_index,
+                    content=AssistantMessageContent(text=""),
+                ),
+            )
+        else:
+            # Since Widgets are recorded in the function responses
+            # they are handled here
+            if fn_responses := event.get_function_responses():
+                for fn_response in fn_responses:
+                    if not fn_response.response:
+                        continue
+                    widget = fn_response.response.get(WIDGET_KEY_IN_TOOL_RESPONSE, None)
+                    if widget:
+                        # No Streaming for Widgets for now
+                        yield ThreadItemDoneEvent(
+                            item=WidgetItem(
+                                id=str(uuid.uuid4()),
+                                thread_id=thread.id,
+                                created_at=datetime.fromtimestamp(event.timestamp),
+                                widget=widget,
+                            )
+                        )
+                    adk_client_tool: ClientToolCallState | None = fn_response.response.get(
+                        CLIENT_TOOL_KEY_IN_TOOL_RESPONSE, None
+                    )
+                    if adk_client_tool:
+                        yield ThreadItemDoneEvent(
+                            item=ClientToolCallItem(
+                                id=event.id,
+                                thread_id=thread.id,
+                                name=adk_client_tool.name,
+                                arguments=adk_client_tool.arguments,
+                                status=adk_client_tool.status,
+                                created_at=datetime.fromtimestamp(event.timestamp),
+                                call_id=adk_client_tool.id,
+                            ),
+                        )
+
+            if event.content.parts:
+                text_from_final_update = ""
+                for p in event.content.parts:
+                    if p.text:
+                        update: AssistantMessageContentPartTextDelta | AssistantMessageContentPartDone
+                        if event.partial:
+                            update = AssistantMessageContentPartTextDelta(
+                                delta=p.text,
+                                content_index=content_index,
+                            )
+                        else:
+                            update = AssistantMessageContentPartDone(
+                                content=AssistantMessageContent(text=p.text),
+                                content_index=content_index,
+                            )
+                            text_from_final_update = p.text
+
+                        yield ThreadItemUpdated(
+                            item_id=response_id,
+                            update=update,
+                        )
+
+                yield ThreadItemDoneEvent(
+                    item=AssistantMessageItem(
+                        id=response_id,
+                        content=[AssistantMessageContent(text=text_from_final_update)],
+                        thread_id=thread.id,
+                        created_at=datetime.fromtimestamp(event.timestamp),
+                    )
+                )

adk_chatkit-0.0.1/src/adk_chatkit/_store.py

@@ -0,0 +1,258 @@
+from datetime import datetime
+from uuid import uuid4
+
+from chatkit.store import Store
+from chatkit.types import (
+    AssistantMessageContent,
+    AssistantMessageItem,
+    Attachment,
+    ClientToolCallItem,
+    InferenceOptions,
+    Page,
+    ThreadItem,
+    ThreadMetadata,
+    UserMessageContent,
+    UserMessageItem,
+    UserMessageTextContent,
+    WidgetItem,
+)
+from chatkit.widgets import Card
+from google.adk.events import Event, EventActions
+from google.adk.sessions import BaseSessionService
+from google.adk.sessions.base_session_service import ListSessionsResponse
+
+from ._client_tool_call import ClientToolCallState
+from ._constants import CHATKIT_THREAD_METADTA_KEY, CLIENT_TOOL_KEY_IN_TOOL_RESPONSE, WIDGET_KEY_IN_TOOL_RESPONSE
+from ._context import ADKContext
+from ._thread_utils import (
+    add_client_tool_status,
+    get_client_tool_status,
+    get_thread_metadata_from_state,
+    serialize_thread_metadata,
+)
+
+
+def _to_user_message_content(event: Event) -> list[UserMessageContent]:
+    if not event.content or not event.content.parts:
+        return []
+
+    contents: list[UserMessageContent] = []
+    for part in event.content.parts:
+        if part.text:
+            contents.append(UserMessageTextContent(text=part.text))
+
+    return contents
+
+
+def _to_assistant_message_content(event: Event) -> list[AssistantMessageContent]:
+    if not event.content or not event.content.parts:
+        return []
+
+    contents: list[AssistantMessageContent] = []
+    for part in event.content.parts:
+        if part.text:
+            contents.append(AssistantMessageContent(text=part.text))
+
+    return contents
+
+
+class ADKStore(Store[ADKContext]):
+    def __init__(self, session_service: BaseSessionService) -> None:
+        self._session_service = session_service
+
+    async def load_thread(self, thread_id: str, context: ADKContext) -> ThreadMetadata:
+        session = await self._session_service.get_session(
+            app_name=context["app_name"],
+            user_id=context["user_id"],
+            session_id=thread_id,
+        )
+
+        if not session:
+            raise ValueError(
+                f"Session with id {thread_id} not found for user {context['user_id']} in app {context['app_name']}"
+            )
+
+        return get_thread_metadata_from_state(session.state)
+
+    async def save_thread(self, thread: ThreadMetadata, context: ADKContext) -> None:
+        session = await self._session_service.get_session(
+            app_name=context["app_name"],
+            user_id=context["user_id"],
+            session_id=thread.id,
+        )
+
+        if not session:
+            session = await self._session_service.create_session(
+                app_name=context["app_name"],
+                user_id=context["user_id"],
+                session_id=thread.id,
+                state={CHATKIT_THREAD_METADTA_KEY: serialize_thread_metadata(thread)},
+            )
+        else:
+            state_delta = {
+                CHATKIT_THREAD_METADTA_KEY: serialize_thread_metadata(thread),
+            }
+            actions_with_update = EventActions(state_delta=state_delta)
+            system_event = Event(
+                invocation_id=uuid4().hex,
+                author="system",
+                actions=actions_with_update,
+                timestamp=datetime.now().timestamp(),
+            )
+            await self._session_service.append_event(session, system_event)
+
+    async def load_thread_items(
+        self,
+        thread_id: str,
+        after: str | None,
+        limit: int,
+        order: str,
+        context: ADKContext,
+    ) -> Page[ThreadItem]:
+        session = await self._session_service.get_session(
+            app_name=context["app_name"],
+            user_id=context["user_id"],
+            session_id=thread_id,
+        )
+
+        if not session:
+            raise ValueError(
+                f"Session with id {thread_id} not found for user {context['user_id']} in app {context['app_name']}"
+            )
+
+        thread_items: list[ThreadItem] = []
+        for event in session.events:
+            an_item: ThreadItem | None = None
+            if event.author == "user":
+                an_item = UserMessageItem(
+                    id=event.id,
+                    thread_id=thread_id,
+                    created_at=datetime.fromtimestamp(event.timestamp),
+                    content=_to_user_message_content(event),
+                    attachments=[],
+                    inference_options=InferenceOptions(),
+                )
+            else:
+                # we should only send the message if it has content
+                # that is not function calls or response
+                text_message_content = _to_assistant_message_content(event)
+
+                if text_message_content:
+                    an_item = AssistantMessageItem(
+                        id=event.id,
+                        thread_id=thread_id,
+                        created_at=datetime.fromtimestamp(event.timestamp),
+                        content=text_message_content,
+                    )
+                else:
+                    # let's see if this a function call response
+                    # with a widget. If yes, then we will tranmist WidgetItem
+                    if fn_responses := event.get_function_responses():
+                        for fn_response in fn_responses:
+                            if not fn_response.response:
+                                continue
+                            # let's check for widget in the response
+                            widget = fn_response.response.get(WIDGET_KEY_IN_TOOL_RESPONSE, None)
+                            if widget:
+                                an_item = WidgetItem(
+                                    id=event.id,
+                                    thread_id=thread_id,
+                                    created_at=datetime.fromtimestamp(event.timestamp),
+                                    widget=Card.model_validate(widget),
+                                )
+                            # let's check for adk-client-tool in the response
+                            adk_client_tool = fn_response.response.get(CLIENT_TOOL_KEY_IN_TOOL_RESPONSE, None)
+                            if adk_client_tool:
+                                adk_client_tool = ClientToolCallState.model_validate(adk_client_tool)
+                                status = get_client_tool_status(
+                                    session.state,
+                                    adk_client_tool.id,
+                                )
+                                if status:
+                                    an_item = ClientToolCallItem(
+                                        id=event.id,
+                                        thread_id=thread_id,
+                                        name=adk_client_tool.name,
+                                        arguments=adk_client_tool.arguments,
+                                        status=status,  # type: ignore
+                                        created_at=datetime.fromtimestamp(event.timestamp),
+                                        call_id=adk_client_tool.id,
+                                    )
+
+            if an_item:
+                thread_items.append(an_item)
+
+        return Page(data=thread_items)
+
+    async def add_thread_item(self, thread_id: str, item: ThreadItem, context: ADKContext) -> None:
+        # items are added to the session by runner
+        pass
+
+    async def save_attachment(self, attachment: Attachment, context: ADKContext) -> None:
+        raise NotImplementedError()
+
+    async def load_attachment(self, attachment_id: str, context: ADKContext) -> Attachment:
+        raise NotImplementedError()
+
+    async def delete_attachment(self, attachment_id: str, context: ADKContext) -> None:
+        raise NotImplementedError()
+
+    async def delete_thread_item(self, thread_id: str, item_id: str, context: ADKContext) -> None:
+        # simply ignoring it for now (ClientToolCallItem is typically not deleted because of this)
+        pass
+
+    async def delete_thread(self, thread_id: str, context: ADKContext) -> None:
+        raise NotImplementedError()
+
+    async def save_item(self, thread_id: str, item: ThreadItem, context: ADKContext) -> None:
+        # we will only handle specify types of items here
+        # as quite many are automatically handled by runner
+        if isinstance(item, ClientToolCallItem):
+            session = await self._session_service.get_session(
+                app_name=context["app_name"],
+                user_id=context["user_id"],
+                session_id=thread_id,
+            )
+
+            if not session:
+                raise ValueError(
+                    f"Session with id {thread_id} not found for user {context['user_id']} in app {context['app_name']}"
+                )
+
+            thread_metadata = add_client_tool_status(session.state, item.call_id, item.status)
+
+            state_delta = {
+                CHATKIT_THREAD_METADTA_KEY: serialize_thread_metadata(thread_metadata),
+            }
+
+            actions_with_update = EventActions(state_delta=state_delta)
+            system_event = Event(
+                invocation_id=uuid4().hex,
+                author="system",
+                actions=actions_with_update,
+                timestamp=datetime.now().timestamp(),
+            )
+            await self._session_service.append_event(session, system_event)
+
+    async def load_item(self, thread_id: str, item_id: str, context: ADKContext) -> ThreadItem:
+        raise NotImplementedError()
+
+    async def load_threads(
+        self,
+        limit: int,
+        after: str | None,
+        order: str,
+        context: ADKContext,
+    ) -> Page[ThreadMetadata]:
+        sessions_response: ListSessionsResponse = await self._session_service.list_sessions(
+            app_name=context["app_name"],
+            user_id=context["user_id"],
+        )
+
+        items: list[ThreadMetadata] = []
+
+        for session in sessions_response.sessions:
+            thread_metadata = get_thread_metadata_from_state(session.state)
+            items.append(thread_metadata)
+
+        return Page(data=items)

adk_chatkit-0.0.1/src/adk_chatkit/_thread_utils.py

@@ -0,0 +1,37 @@
+import json
+from typing import Any
+
+from chatkit.types import ThreadMetadata
+from google.adk.sessions.state import State
+
+from ._constants import CHATKIT_THREAD_METADTA_KEY
+
+_CLIENT_TOOL_PREFIX = "client-tool"
+
+
+def serialize_thread_metadata(thread: ThreadMetadata) -> dict[str, Any]:
+    json_dump = thread.model_dump_json(exclude_none=True, exclude={"items"})
+    return json.loads(json_dump)  # type: ignore
+
+
+def get_thread_metadata_from_state(state: State | dict[str, Any]) -> ThreadMetadata:
+    thread_metadata_dict = state[CHATKIT_THREAD_METADTA_KEY]
+    return ThreadMetadata.model_validate(thread_metadata_dict)
+
+
+def add_client_tool_status(
+    state: State | dict[str, Any],
+    client_tool_id: str,
+    status: str,
+) -> ThreadMetadata:
+    thread_metadata = get_thread_metadata_from_state(state)
+    thread_metadata.metadata[f"{_CLIENT_TOOL_PREFIX}-{client_tool_id}"] = status
+    return thread_metadata
+
+
+def get_client_tool_status(
+    state: State | dict[str, Any],
+    client_tool_id: str,
+) -> str | None:
+    thread_metadata = get_thread_metadata_from_state(state)
+    return thread_metadata.metadata.get(f"{_CLIENT_TOOL_PREFIX}-{client_tool_id}", None)

adk_chatkit-0.0.1/src/adk_chatkit/_widgets.py

@@ -0,0 +1,18 @@
+from typing import Any
+
+from chatkit.widgets import WidgetRoot
+
+from ._constants import WIDGET_KEY_IN_TOOL_RESPONSE
+
+
+def add_widget_to_tool_response(
+    response: dict[str, Any],
+    widget: WidgetRoot,
+) -> None:
+    """Add a widget to a tool response dictionary.
+
+    Args:
+        response: The tool response dictionary to modify.
+        widget: The widget to add.
+    """
+    response[WIDGET_KEY_IN_TOOL_RESPONSE] = widget