gitcode-api 1.2.9__tar.gz → 1.2.11__tar.gz

{gitcode_api-1.2.9 → gitcode_api-1.2.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitcode-api
-Version: 1.2.9
+Version: 1.2.11
 Summary: Easy to use Python SDK for the GitCode REST API. Providing builtin CLI tool, and optional LLM integration (MCP, OpenAI tool, and openJiuwen tool) for agents. Community-maintained.
 Author-email: Hugo Huang <hugo@hugohuang.com>
 License-Expression: MIT
@@ -231,7 +231,7 @@ Every resource group inherits a cached `methods` property from the shared resour
 
 ## LLM tools, MCP, and openJiuwen
 
-The `gitcode_api.llm` module exposes a single logical tool, **`gitcode_api_tool`**, that routes calls to sync or async SDK resources. Model-facing parameters match the JSON schema used by OpenAI-style function tools:
+The `gitcode_api.llm` module exposes a single unified tool, **`gitcode_api_tool`**, that routes calls to respective sync or async SDK resource groups. Model-facing parameters match the JSON schema used by OpenAI-style function tools:
 
 | Parameter | Role |
 | --- | --- |
@@ -240,11 +240,11 @@ The `gitcode_api.llm` module exposes a single logical tool, **`gitcode_api_tool`
 | `params` | Keyword arguments for the method as a JSON object; omitted or `null` is treated as `{}`. |
 | `help` | When `true`, returns formatted help (available methods or a target signature) instead of performing a normal API call where applicable. |
 
-Successful results are JSON-friendly (`APIObject.to_dict()`, base64-wrapped `bytes`, and similar). Failures are returned as objects with `"error": true` and a `"message"` string (HTTP and configuration errors include extra fields when available).
+Tool payloads are JSON-serialized strings: successes look like plain objects (`APIObject.to_dict()`, base64-wrapped `bytes`, and similar); failures use `"error": true`, a `"message"` string, and optional extra fields on HTTP/configuration errors.
 
 ### OpenAI tool (`GitCodeOpenAITool`)
 
-No extra dependencies beyond the core package. Build a Chat Completions–style tool definition with `.tool` or `.to_dict()`, then invoke the same instance with the arguments above (sync) or configure async mode for `await`.
+No extra dependencies beyond the core package. Build a Chat Completions–style tool definition with `.tool` or `.to_dict()`, then invoke the same instance with the arguments above (sync) or configure async mode for `await`. Each invocation applies `json.dumps` to payload so the return type is **always `str`**. The default keyword argument `indent=2` pretty-prints JSON; pass `indent=None` for a compact single-line string.
 
 ```python
 from gitcode_api.llm import GitCodeOpenAITool
@@ -265,33 +265,43 @@ and handle tool calls directly:
 
 ```python
 import json
-from openai import OpenAI
-from gitcode_api.llm import GitCodeOpenAITool
+import os
+from typing import Dict, List
 
-tools = {
-    "gitcode_api_tool": GitCodeOpenAITool(owner="SushiNinja", repo="GitCode-API"),
-}
-client = OpenAI(
-    api_key="your-openai-compatible-api-key",
-    base_url="https://your-openai-compatible-base-url/v1",
-)
+from openai import OpenAI
 
-response = client.chat.completions.create(
-    model="gpt-4.1-mini",
-    messages=[{"role": "user", "content": "List the last 5 commits."}],
-    tools=[tools["gitcode_api_tool"].tool],
-)
+from gitcode_api.llm import GitCodeOpenAITool
 
-for tool_call in response.choices[0].message.tool_calls:
-    selected_tool = tools[tool_call.function.name]
-    print(f"Calling tool {tool_call.function.name}({tool_call.function.arguments}):")
-    print("---result---")
-    print(selected_tool(**json.loads(tool_call.function.arguments)))
-    print("---result---")
+MESSAGE_SEP = "\n" + "=" * 60 + "\n"
+USER_QUERY = "List the repos owned by SushiNinja."
+CONVERSATION: List[Dict[str, str]] = [dict(role="user", content=USER_QUERY)]
+
+tools = {"gitcode_api_tool": GitCodeOpenAITool()}
+client = OpenAI()
+
+print("U:\n" + USER_QUERY + MESSAGE_SEP)
+while True:
+    response = (
+        client.chat.completions.create(
+            model="gpt-5.4-nano",
+            messages=CONVERSATION,
+            tools=[tools["gitcode_api_tool"].tool],
+        )
+        .choices[0]
+        .message
+    )
+    CONVERSATION.append(response.to_dict())
+    print("A:\n" + (response.content or ""))
+    for tool_call in response.tool_calls or []:
+        selected_tool = tools[tool_call.function.name]
+        result = selected_tool(**json.loads(tool_call.function.arguments))
+        CONVERSATION.append(dict(role="tool", tool_call_id=tool_call.id, content=result))
+        print(f"<Calling tool {tool_call.function.name}({tool_call.function.arguments})>")
+    print(MESSAGE_SEP)
+    if not response.tool_calls:
+        break
 ```
 
-Constructor options mirror `GitCode` / `AsyncGitCode`: `client=`, `async_client=`, `api_key=`, `owner=`, `repo=`, `base_url=`, `timeout=`, and `decrypt=`. For dict-driven setups that reserve the name `async`, you may pass `**{"async": True}` instead of `async_mode=True` (but not both).
-
 ### MCP server and MCP tool (FastMCP)
 
 [MCP](https://modelcontextprotocol.io) integration uses [FastMCP](https://github.com/jlowin/fastmcp). Install the optional extra (requires **Python 3.10+** because of the `fastmcp` dependency):

{gitcode_api-1.2.9 → gitcode_api-1.2.11}/README.md

@@ -194,7 +194,7 @@ Every resource group inherits a cached `methods` property from the shared resour
 
 ## LLM tools, MCP, and openJiuwen
 
-The `gitcode_api.llm` module exposes a single logical tool, **`gitcode_api_tool`**, that routes calls to sync or async SDK resources. Model-facing parameters match the JSON schema used by OpenAI-style function tools:
+The `gitcode_api.llm` module exposes a single unified tool, **`gitcode_api_tool`**, that routes calls to respective sync or async SDK resource groups. Model-facing parameters match the JSON schema used by OpenAI-style function tools:
 
 | Parameter | Role |
 | --- | --- |
@@ -203,11 +203,11 @@ The `gitcode_api.llm` module exposes a single logical tool, **`gitcode_api_tool`
 | `params` | Keyword arguments for the method as a JSON object; omitted or `null` is treated as `{}`. |
 | `help` | When `true`, returns formatted help (available methods or a target signature) instead of performing a normal API call where applicable. |
 
-Successful results are JSON-friendly (`APIObject.to_dict()`, base64-wrapped `bytes`, and similar). Failures are returned as objects with `"error": true` and a `"message"` string (HTTP and configuration errors include extra fields when available).
+Tool payloads are JSON-serialized strings: successes look like plain objects (`APIObject.to_dict()`, base64-wrapped `bytes`, and similar); failures use `"error": true`, a `"message"` string, and optional extra fields on HTTP/configuration errors.
 
 ### OpenAI tool (`GitCodeOpenAITool`)
 
-No extra dependencies beyond the core package. Build a Chat Completions–style tool definition with `.tool` or `.to_dict()`, then invoke the same instance with the arguments above (sync) or configure async mode for `await`.
+No extra dependencies beyond the core package. Build a Chat Completions–style tool definition with `.tool` or `.to_dict()`, then invoke the same instance with the arguments above (sync) or configure async mode for `await`. Each invocation applies `json.dumps` to payload so the return type is **always `str`**. The default keyword argument `indent=2` pretty-prints JSON; pass `indent=None` for a compact single-line string.
 
 ```python
 from gitcode_api.llm import GitCodeOpenAITool
@@ -228,33 +228,43 @@ and handle tool calls directly:
 
 ```python
 import json
-from openai import OpenAI
-from gitcode_api.llm import GitCodeOpenAITool
+import os
+from typing import Dict, List
 
-tools = {
-    "gitcode_api_tool": GitCodeOpenAITool(owner="SushiNinja", repo="GitCode-API"),
-}
-client = OpenAI(
-    api_key="your-openai-compatible-api-key",
-    base_url="https://your-openai-compatible-base-url/v1",
-)
+from openai import OpenAI
 
-response = client.chat.completions.create(
-    model="gpt-4.1-mini",
-    messages=[{"role": "user", "content": "List the last 5 commits."}],
-    tools=[tools["gitcode_api_tool"].tool],
-)
+from gitcode_api.llm import GitCodeOpenAITool
 
-for tool_call in response.choices[0].message.tool_calls:
-    selected_tool = tools[tool_call.function.name]
-    print(f"Calling tool {tool_call.function.name}({tool_call.function.arguments}):")
-    print("---result---")
-    print(selected_tool(**json.loads(tool_call.function.arguments)))
-    print("---result---")
+MESSAGE_SEP = "\n" + "=" * 60 + "\n"
+USER_QUERY = "List the repos owned by SushiNinja."
+CONVERSATION: List[Dict[str, str]] = [dict(role="user", content=USER_QUERY)]
+
+tools = {"gitcode_api_tool": GitCodeOpenAITool()}
+client = OpenAI()
+
+print("U:\n" + USER_QUERY + MESSAGE_SEP)
+while True:
+    response = (
+        client.chat.completions.create(
+            model="gpt-5.4-nano",
+            messages=CONVERSATION,
+            tools=[tools["gitcode_api_tool"].tool],
+        )
+        .choices[0]
+        .message
+    )
+    CONVERSATION.append(response.to_dict())
+    print("A:\n" + (response.content or ""))
+    for tool_call in response.tool_calls or []:
+        selected_tool = tools[tool_call.function.name]
+        result = selected_tool(**json.loads(tool_call.function.arguments))
+        CONVERSATION.append(dict(role="tool", tool_call_id=tool_call.id, content=result))
+        print(f"<Calling tool {tool_call.function.name}({tool_call.function.arguments})>")
+    print(MESSAGE_SEP)
+    if not response.tool_calls:
+        break
 ```
 
-Constructor options mirror `GitCode` / `AsyncGitCode`: `client=`, `async_client=`, `api_key=`, `owner=`, `repo=`, `base_url=`, `timeout=`, and `decrypt=`. For dict-driven setups that reserve the name `async`, you may pass `**{"async": True}` instead of `async_mode=True` (but not both).
-
 ### MCP server and MCP tool (FastMCP)
 
 [MCP](https://modelcontextprotocol.io) integration uses [FastMCP](https://github.com/jlowin/fastmcp). Install the optional extra (requires **Python 3.10+** because of the `fastmcp` dependency):

{gitcode_api-1.2.9 → gitcode_api-1.2.11}/gitcode_api/llm/__init__.py

@@ -3,6 +3,8 @@
 from importlib import import_module
 from typing import TYPE_CHECKING, Any, Dict
 
+from ._tool import GitCodeLLMTool
+
 if TYPE_CHECKING:
     from .jiuwen import create_openjiuwen_gitcode_api_tool
     from .mcp import (
@@ -25,7 +27,7 @@ _IMPORT_MAP = {
     "create_openjiuwen_gitcode_api_tool": ".jiuwen",
 }
 
-_IMPORT_CACHE: Dict[str, Any] = {}
+_IMPORT_CACHE: Dict[str, Any] = {"GitCodeLLMTool": GitCodeLLMTool}
 
 
 def __getattr__(name: str) -> object:
@@ -50,6 +52,7 @@ def __dir__() -> list[str]:
 
 
 __all__ = [
+    "GitCodeLLMTool",
     "GitCodeOpenAITool",
     "GitCodeMCP",
     "create_mcp_gitcode_api_tool",

{gitcode_api-1.2.9 → gitcode_api-1.2.11}/gitcode_api/llm/jiuwen.py

@@ -11,6 +11,7 @@ from ._tool import TOOL_DESCRIPTION, TOOL_NAME, TOOL_PARAMETERS, GitCodeLLMTool
 if TYPE_CHECKING:
     from openjiuwen.core.foundation.tool import LocalFunction
 
+
 def _missing_openjiuwen_error() -> ImportError:
     return ImportError(
         "The openJiuwen tool support requires the optional dependency: pip install openjiuwen. "
@@ -29,8 +30,30 @@ def _openjiuwen_tool_decorator() -> Callable[..., Any]:
 class _GitCodeJiuwenTool(GitCodeLLMTool):
     """Build an openJiuwen ``LocalFunction`` bound to :class:`GitCodeLLMTool` (async invoke only)."""
 
-    def __init__(self, *, name: Optional[str] = None, description: Optional[str] = None, **kwargs) -> None:
-        super().__init__(**kwargs)
+    def __init__(
+        self,
+        *,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        client: Optional[GitCode] = None,
+        async_client: Optional[AsyncGitCode] = None,
+        api_key: Optional[str] = None,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: Optional[float] = None,
+        decrypt: Optional[Callable[..., Any]] = None,
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+    ) -> None:
+        super().__init__(
+            client=client,
+            async_client=async_client,
+            api_key=api_key,
+            owner=owner,
+            repo=repo,
+            base_url=base_url,
+            timeout=timeout,
+            decrypt=decrypt,
+        )
         tool_name = name if name is not None else TOOL_NAME
         tool_description = description if description is not None else TOOL_DESCRIPTION
         oj_tool = _openjiuwen_tool_decorator()
@@ -59,11 +82,11 @@ def create_openjiuwen_gitcode_api_tool(
     client: Optional[GitCode] = None,
     async_client: Optional[AsyncGitCode] = None,
     api_key: Optional[str] = None,
-    owner: Optional[str] = None,
-    repo: Optional[str] = None,
     base_url: str = DEFAULT_BASE_URL,
     timeout: Optional[float] = None,
     decrypt: Optional[Callable[..., Any]] = None,
+    owner: Optional[str] = None,
+    repo: Optional[str] = None,
 ) -> "LocalFunction":
     """Create an openJiuwen ``LocalFunction`` for the GitCode API tool.
 
@@ -72,11 +95,11 @@ def create_openjiuwen_gitcode_api_tool(
     :param client: Optional synchronous GitCode client.
     :param async_client: Optional asynchronous GitCode client.
     :param api_key: Personal access token when clients are not supplied.
-    :param owner: Default repository owner for generated clients.
-    :param repo: Default repository name for generated clients.
     :param base_url: Base URL for generated clients.
     :param timeout: Request timeout for generated clients.
     :param decrypt: Optional decryption function for encrypted access tokens.
+    :param owner: Default repository owner for generated clients.
+    :param repo: Default repository name for generated clients.
     :returns: openJiuwen ``LocalFunction`` with the standard parameter schema.
     """
     adapter = _GitCodeJiuwenTool(

gitcode_api-1.2.11/gitcode_api/llm/openai.py

@@ -0,0 +1,88 @@
+"""OpenAI tool adapter for the GitCode SDK."""
+
+import json
+from functools import cached_property
+from typing import Any, Callable, Coroutine, Dict, Optional, Union
+
+from gitcode_api import AsyncGitCode, GitCode
+from gitcode_api._base_client import DEFAULT_BASE_URL
+
+from ._tool import TOOL_DESCRIPTION, TOOL_NAME, TOOL_PARAMETERS, GitCodeLLMTool
+
+
+class GitCodeOpenAITool(GitCodeLLMTool):
+    """OpenAI-compatible callable tool for invoking GitCode SDK resources.
+
+    :param async_mode: When true, calling the instance returns the async tool coroutine.
+    :param indent: ``indent`` argument passed to :func:`json.dumps` when serializing
+        invocation results (default ``2``).
+    :param client: Optional synchronous GitCode client.
+    :param async_client: Optional asynchronous GitCode client.
+    :param api_key: Personal access token used when clients are not supplied.
+    :param base_url: Base URL for generated clients.
+    :param timeout: Request timeout for generated clients.
+    :param decrypt: Optional decryption function for encrypted access tokens.
+    :param owner: Default repository owner for generated clients.
+    :param repo: Default repository name for generated clients.
+    """
+
+    name = TOOL_NAME
+    description = TOOL_DESCRIPTION
+    parameters = TOOL_PARAMETERS
+
+    def __init__(
+        self,
+        async_mode: bool = False,
+        indent: int = 2,
+        *,
+        client: Optional[GitCode] = None,
+        async_client: Optional[AsyncGitCode] = None,
+        api_key: Optional[str] = None,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: Optional[float] = None,
+        decrypt: Optional[Callable] = None,
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+    ) -> None:
+        """Create an OpenAI tool wrapper."""
+        self.indent = indent
+        self.async_mode = bool(async_mode)
+        super().__init__(
+            client=client,
+            async_client=async_client,
+            api_key=api_key,
+            owner=owner,
+            repo=repo,
+            base_url=base_url,
+            timeout=timeout,
+            decrypt=decrypt,
+        )
+
+    @cached_property
+    def tool(self) -> Dict[str, Any]:
+        """Return this tool in OpenAI Chat Completions tool format."""
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": self.description,
+                "parameters": self.parameters,
+            },
+        }
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return this tool in OpenAI Chat Completions tool format."""
+        return self.tool
+
+    async def __async_call__(self, *args, **kwargs) -> str:
+        result = await super().__async_call__(*args, **kwargs)
+        return json.dumps(result, ensure_ascii=False, indent=self.indent)
+
+    def __call__(self, *args, **kwargs) -> Union[str, Coroutine[Any, Any, str]]:
+        """Invoke the configured sync or async tool callable."""
+        if self.async_mode:
+            return self.__async_call__(*args, **kwargs)
+        return json.dumps(super().__call__(*args, **kwargs), ensure_ascii=False, indent=self.indent)
+
+
+__all__ = ["GitCodeOpenAITool"]

gitcode_api-1.2.11/gitcode_api/version.txt

@@ -0,0 +1 @@
+1.2.11

{gitcode_api-1.2.9 → gitcode_api-1.2.11}/gitcode_api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitcode-api
-Version: 1.2.9
+Version: 1.2.11
 Summary: Easy to use Python SDK for the GitCode REST API. Providing builtin CLI tool, and optional LLM integration (MCP, OpenAI tool, and openJiuwen tool) for agents. Community-maintained.
 Author-email: Hugo Huang <hugo@hugohuang.com>
 License-Expression: MIT
@@ -231,7 +231,7 @@ Every resource group inherits a cached `methods` property from the shared resour
 
 ## LLM tools, MCP, and openJiuwen
 
-The `gitcode_api.llm` module exposes a single logical tool, **`gitcode_api_tool`**, that routes calls to sync or async SDK resources. Model-facing parameters match the JSON schema used by OpenAI-style function tools:
+The `gitcode_api.llm` module exposes a single unified tool, **`gitcode_api_tool`**, that routes calls to respective sync or async SDK resource groups. Model-facing parameters match the JSON schema used by OpenAI-style function tools:
 
 | Parameter | Role |
 | --- | --- |
@@ -240,11 +240,11 @@ The `gitcode_api.llm` module exposes a single logical tool, **`gitcode_api_tool`
 | `params` | Keyword arguments for the method as a JSON object; omitted or `null` is treated as `{}`. |
 | `help` | When `true`, returns formatted help (available methods or a target signature) instead of performing a normal API call where applicable. |
 
-Successful results are JSON-friendly (`APIObject.to_dict()`, base64-wrapped `bytes`, and similar). Failures are returned as objects with `"error": true` and a `"message"` string (HTTP and configuration errors include extra fields when available).
+Tool payloads are JSON-serialized strings: successes look like plain objects (`APIObject.to_dict()`, base64-wrapped `bytes`, and similar); failures use `"error": true`, a `"message"` string, and optional extra fields on HTTP/configuration errors.
 
 ### OpenAI tool (`GitCodeOpenAITool`)
 
-No extra dependencies beyond the core package. Build a Chat Completions–style tool definition with `.tool` or `.to_dict()`, then invoke the same instance with the arguments above (sync) or configure async mode for `await`.
+No extra dependencies beyond the core package. Build a Chat Completions–style tool definition with `.tool` or `.to_dict()`, then invoke the same instance with the arguments above (sync) or configure async mode for `await`. Each invocation applies `json.dumps` to payload so the return type is **always `str`**. The default keyword argument `indent=2` pretty-prints JSON; pass `indent=None` for a compact single-line string.
 
 ```python
 from gitcode_api.llm import GitCodeOpenAITool
@@ -265,33 +265,43 @@ and handle tool calls directly:
 
 ```python
 import json
-from openai import OpenAI
-from gitcode_api.llm import GitCodeOpenAITool
+import os
+from typing import Dict, List
 
-tools = {
-    "gitcode_api_tool": GitCodeOpenAITool(owner="SushiNinja", repo="GitCode-API"),
-}
-client = OpenAI(
-    api_key="your-openai-compatible-api-key",
-    base_url="https://your-openai-compatible-base-url/v1",
-)
+from openai import OpenAI
 
-response = client.chat.completions.create(
-    model="gpt-4.1-mini",
-    messages=[{"role": "user", "content": "List the last 5 commits."}],
-    tools=[tools["gitcode_api_tool"].tool],
-)
+from gitcode_api.llm import GitCodeOpenAITool
 
-for tool_call in response.choices[0].message.tool_calls:
-    selected_tool = tools[tool_call.function.name]
-    print(f"Calling tool {tool_call.function.name}({tool_call.function.arguments}):")
-    print("---result---")
-    print(selected_tool(**json.loads(tool_call.function.arguments)))
-    print("---result---")
+MESSAGE_SEP = "\n" + "=" * 60 + "\n"
+USER_QUERY = "List the repos owned by SushiNinja."
+CONVERSATION: List[Dict[str, str]] = [dict(role="user", content=USER_QUERY)]
+
+tools = {"gitcode_api_tool": GitCodeOpenAITool()}
+client = OpenAI()
+
+print("U:\n" + USER_QUERY + MESSAGE_SEP)
+while True:
+    response = (
+        client.chat.completions.create(
+            model="gpt-5.4-nano",
+            messages=CONVERSATION,
+            tools=[tools["gitcode_api_tool"].tool],
+        )
+        .choices[0]
+        .message
+    )
+    CONVERSATION.append(response.to_dict())
+    print("A:\n" + (response.content or ""))
+    for tool_call in response.tool_calls or []:
+        selected_tool = tools[tool_call.function.name]
+        result = selected_tool(**json.loads(tool_call.function.arguments))
+        CONVERSATION.append(dict(role="tool", tool_call_id=tool_call.id, content=result))
+        print(f"<Calling tool {tool_call.function.name}({tool_call.function.arguments})>")
+    print(MESSAGE_SEP)
+    if not response.tool_calls:
+        break
 ```
 
-Constructor options mirror `GitCode` / `AsyncGitCode`: `client=`, `async_client=`, `api_key=`, `owner=`, `repo=`, `base_url=`, `timeout=`, and `decrypt=`. For dict-driven setups that reserve the name `async`, you may pass `**{"async": True}` instead of `async_mode=True` (but not both).
-
 ### MCP server and MCP tool (FastMCP)
 
 [MCP](https://modelcontextprotocol.io) integration uses [FastMCP](https://github.com/jlowin/fastmcp). Install the optional extra (requires **Python 3.10+** because of the `fastmcp` dependency):

{gitcode_api-1.2.9 → gitcode_api-1.2.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "gitcode-api"
-version = "1.2.9"
+version = "1.2.11"
 description = "Easy to use Python SDK for the GitCode REST API. Providing builtin CLI tool, and optional LLM integration (MCP, OpenAI tool, and openJiuwen tool) for agents. Community-maintained."
 keywords = [
     "gitcode", "git", "devops", "api", "sdk", "python", "httpx", "client",

{gitcode_api-1.2.9 → gitcode_api-1.2.11}/tests/test_llm_tools.py

@@ -1,4 +1,5 @@
 import importlib.util
+import json
 from typing import Any, Dict
 
 import httpx
@@ -44,7 +45,7 @@ def test_openai_tool_invokes_sync_client(sync_client_factory: Any) -> None:
         http_client.close()
 
     assert "/repos/SushiNinja/GitCode-API" in captured["url"]
-    assert result == {"full_name": "SushiNinja/GitCode-API"}
+    assert json.loads(result) == {"full_name": "SushiNinja/GitCode-API"}
 
 
 @pytest.mark.asyncio
@@ -63,7 +64,7 @@ async def test_openai_tool_invokes_async_client(async_client_factory: Any) -> No
         await http_client.aclose()
 
     assert "/users/octocat" in captured["url"]
-    assert result == {"login": "octocat"}
+    assert json.loads(result) == {"login": "octocat"}
 
 
 def test_tool_help_does_not_require_api_key(monkeypatch: Any) -> None:
@@ -129,20 +130,6 @@ def test_help_resource_index_body() -> None:
         assert f"gitcode-api://help/{name}" in body
 
 
-@pytest.mark.asyncio
-async def test_create_mcp_server_registers_help_resources() -> None:
-    mcp = create_mcp_server()
-    static = await mcp._list_resources_mcp()
-    templates = await mcp._list_resource_templates_mcp()
-    assert any(str(r.uri) == "gitcode-api://help" for r in static)
-    assert any(
-        "{op_type}" in str(getattr(t, "uri_template", None) or getattr(t, "uriTemplate", None)) for t in templates
-    )
-    read = await mcp._read_resource_mcp("gitcode-api://help/pulls")
-    payload = read[0].content
-    assert "Resource: pulls" in payload
-
-
 def test_mcp_registers_with_existing_server() -> None:
     class DummyMCP:
         def __init__(self) -> None:

gitcode_api-1.2.9/gitcode_api/llm/openai.py

@@ -1,56 +0,0 @@
-"""OpenAI tool adapter for the GitCode SDK."""
-
-from functools import cached_property
-from typing import Any, Dict, Optional
-
-from ._tool import TOOL_DESCRIPTION, TOOL_NAME, TOOL_PARAMETERS, GitCodeLLMTool
-
-
-class GitCodeOpenAITool(GitCodeLLMTool):
-    """OpenAI-compatible callable tool for invoking GitCode SDK resources.
-
-    :param async_mode: When true, calling the instance returns the async tool coroutine.
-    :param kwargs: Forwarded to :class:`gitcode_api.llm.GitCodeLLMTool`. ``{"async": True}``
-        is also accepted for frameworks that construct tools from dictionaries.
-    """
-
-    name = TOOL_NAME
-    description = TOOL_DESCRIPTION
-    parameters = TOOL_PARAMETERS
-
-    def __init__(self, async_mode: Optional[bool] = None, **kwargs) -> None:
-        """Create an OpenAI tool wrapper."""
-        async_kw = kwargs.pop("async", None)
-        if async_mode is None:
-            async_mode = bool(async_kw)
-        elif async_kw is not None:
-            raise TypeError("Pass only one of async_mode or async")
-        self.async_mode = bool(async_mode)
-        super().__init__(**kwargs)
-        if self.async_mode:
-            self.__call__ = self.__async_call__  # type: ignore[method-assign]
-
-    @cached_property
-    def tool(self) -> Dict[str, Any]:
-        """Return this tool in OpenAI Chat Completions tool format."""
-        return {
-            "type": "function",
-            "function": {
-                "name": self.name,
-                "description": self.description,
-                "parameters": self.parameters,
-            },
-        }
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Return this tool in OpenAI Chat Completions tool format."""
-        return self.tool
-
-    def __call__(self, *args: Any, **kwargs) -> Any:
-        """Invoke the configured sync or async tool callable."""
-        if self.async_mode:
-            return self.__async_call__(*args, **kwargs)
-        return super().__call__(*args, **kwargs)
-
-
-__all__ = ["GitCodeOpenAITool"]

gitcode_api-1.2.9/gitcode_api/version.txt

@@ -1 +0,0 @@
-1.2.9

{gitcode_api-1.2.9 → gitcode_api-1.2.11}/gitcode_api/llm/_tool.py

@@ -227,11 +227,11 @@ class GitCodeLLMTool:
     :param client: Optional synchronous GitCode client.
     :param async_client: Optional asynchronous GitCode client.
     :param api_key: Personal access token used when clients are not supplied.
-    :param owner: Default repository owner for generated clients.
-    :param repo: Default repository name for generated clients.
     :param base_url: Base URL for generated clients.
     :param timeout: Request timeout for generated clients.
     :param decrypt: Optional decryption function for encrypted access tokens.
+    :param owner: Default repository owner for generated clients.
+    :param repo: Default repository name for generated clients.
     """
 
     def __init__(
@@ -240,11 +240,11 @@ class GitCodeLLMTool:
         client: Optional[GitCode] = None,
         async_client: Optional[AsyncGitCode] = None,
         api_key: Optional[str] = None,
-        owner: Optional[str] = None,
-        repo: Optional[str] = None,
         base_url: str = DEFAULT_BASE_URL,
         timeout: Optional[float] = None,
         decrypt: Optional[Callable] = None,
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
     ) -> None:
         """Create a reusable tool with lazy sync and async clients."""
         self._client = client