PyPI - gitcode-api - Versions diffs - 1.2.8__tar.gz → 1.2.10__tar.gz - Mend

gitcode-api 1.2.8tar.gz → 1.2.10tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (45) hide show

{gitcode_api-1.2.8 → gitcode_api-1.2.10}/PKG-INFO RENAMED Viewed

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: gitcode-api
-Version: 1.2.8
-Summary: Easy to use Python SDK for the GitCode REST API. Providing builtin CLI tool, and optional LLM integration (MCP and OpenAI tool) for agents. Community-maintained.
+Version: 1.2.10
+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
 Project-URL: changelog, https://gitcode-api.readthedocs.io/en/latest/changelog.html
@@ -11,7 +11,7 @@ Project-URL: gitcode, https://gitcode.com/SushiNinja/GitCode-API
 Project-URL: github, https://github.com/Trenza1ore/GitCode-API
 Project-URL: homepage, https://linktr.ee/Hugoooo
 Project-URL: author, https://hugohuang.com
-Keywords: gitcode,git,devops,api,sdk,python,httpx,client,mcp,agent,fastmcp,llm,mcp client,mcp server,model context protocol
+Keywords: gitcode,git,devops,api,sdk,python,httpx,client,mcp,agent,fastmcp,llm,openjiuwen,mcp client,mcp server,model context protocol
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: Implementation :: CPython
@@ -38,12 +38,12 @@ Dynamic: license-file
 # GitCode-API
 [![PyPI - Version](https://img.shields.io/pypi/v/gitcode-api?link=https%3A%2F%2Fpypi.org%2Fproject%2Fgitcode-api%2F)](https://pypi.org/project/gitcode-api) [![PyPI Downloads](https://static.pepy.tech/personalized-badge/gitcode-api?period=total&units=INTERNATIONAL_SYSTEM&left_color=GRAY&right_color=RED&left_text=downloads)](https://pepy.tech/projects/gitcode-api) [![CodeFactor](https://www.codefactor.io/repository/github/trenza1ore/gitcode-api/badge)](https://www.codefactor.io/repository/github/trenza1ore/gitcode-api)
-[![Install in Cursor](https://img.shields.io/badge/Install_in-Cursor-000000?style=flat-square&logoColor=white)](https://cursor.com/en/install-mcp?name=GitCode%20API&config=eyJjb21tYW5kIjoidXZ4IiwiYXJncyI6WyItLWZyb20iLCJnaXRjb2RlLWFwaVttY3BdIiwiZ2l0Y29kZS1hcGkiLCJzZXJ2ZSJdLCJlbnYiOnsiR0lUQ09ERV9BQ0NFU1NfVE9LRU4iOiIke2lucHV0OmdpdGNvZGVfYWNjZXNzX3Rva2VufSJ9LCJpbnB1dHMiOlt7ImlkIjoiZ2l0Y29kZV9hY2Nlc3NfdG9rZW4iLCJ0eXBlIjoicHJvbXB0U3RyaW5nIiwiZGVzY3JpcHRpb24iOiJFbnRlciBHSVRDT0RFX0FDQ0VTU19UT0tFTiIsInBhc3N3b3JkIjp0cnVlfV19) [![Install in VS Code](https://img.shields.io/badge/Install_in-VS_Code-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://vscode.dev/redirect/mcp/install?name=GitCode%20API&config=%7B%22command%22%3A%22uvx%22%2C%22args%22%3A%5B%22--from%22%2C%22gitcode-api%5Bmcp%5D%22%2C%22gitcode-api%22%2C%22serve%22%5D%2C%22env%22%3A%7B%22GITCODE_ACCESS_TOKEN%22%3A%22%24%7Binput%3Agitcode_access_token%7D%22%7D%2C%22inputs%22%3A%5B%7B%22id%22%3A%22gitcode_access_token%22%2C%22type%22%3A%22promptString%22%2C%22description%22%3A%22Enter%20GITCODE_ACCESS_TOKEN%22%2C%22password%22%3Atrue%7D%5D%7D)
+[![Install in Cursor](https://img.shields.io/badge/Install_in-Cursor-000000?logoColor=white)](https://cursor.com/en/install-mcp?name=GitCode%20API&config=eyJjb21tYW5kIjoidXZ4IiwiYXJncyI6WyItLWZyb20iLCJnaXRjb2RlLWFwaVttY3BdIiwiZ2l0Y29kZS1hcGkiLCJzZXJ2ZSJdLCJlbnYiOnsiR0lUQ09ERV9BQ0NFU1NfVE9LRU4iOiIke2lucHV0OmdpdGNvZGVfYWNjZXNzX3Rva2VufSJ9LCJpbnB1dHMiOlt7ImlkIjoiZ2l0Y29kZV9hY2Nlc3NfdG9rZW4iLCJ0eXBlIjoicHJvbXB0U3RyaW5nIiwiZGVzY3JpcHRpb24iOiJFbnRlciBHSVRDT0RFX0FDQ0VTU19UT0tFTiIsInBhc3N3b3JkIjp0cnVlfV19) [![Install in VS Code](https://img.shields.io/badge/Install_in-VS_Code-0098FF?logo=visualstudiocode&logoColor=white)](https://vscode.dev/redirect/mcp/install?name=GitCode%20API&config=%7B%22command%22%3A%22uvx%22%2C%22args%22%3A%5B%22--from%22%2C%22gitcode-api%5Bmcp%5D%22%2C%22gitcode-api%22%2C%22serve%22%5D%2C%22env%22%3A%7B%22GITCODE_ACCESS_TOKEN%22%3A%22%24%7Binput%3Agitcode_access_token%7D%22%7D%2C%22inputs%22%3A%5B%7B%22id%22%3A%22gitcode_access_token%22%2C%22type%22%3A%22promptString%22%2C%22description%22%3A%22Enter%20GITCODE_ACCESS_TOKEN%22%2C%22password%22%3Atrue%7D%5D%7D)
 [![GitHub Badge](https://img.shields.io/badge/github-repo-blue?logo=github&link=https%3A%2F%2Fgithub.com%2FTrenza1ore%2FGitCode-API)](https://github.com/Trenza1ore/GitCode-API) [![GitCode Badge](https://img.shields.io/badge/gitcode-repo-brown?logo=gitcode&link=https%3A%2F%2Fgitcode.com%2FSushiNinja%2FGitCode-API)](https://gitcode.com/SushiNinja/GitCode-API)
 [![Docs](https://img.shields.io/badge/%E6%96%87%E6%A1%A3-Docs-cyan?style=for-the-badge&logo=readthedocs&link=https%3A%2F%2Fgitcode-api.readthedocs.io%2Fen%2Flatest%2Findex.html)](https://gitcode-api.readthedocs.io) [![中文README](https://img.shields.io/badge/%E4%B8%AD%E6%96%87-README-brown?style=for-the-badge&logo=googledocs&link=README.zh.md)](README.zh.md)
-`gitcode-api` is a community-maintained Python SDK for the GitCode REST API. It provides easy-to-use synchronous and asynchronous clients, repository-scoped helpers, and lightweight response models so you can work with GitCode from Python without hand-writing raw HTTP requests. The `gitcode_api.llm` module adds an OpenAI-style function tool and MCP service so agents can reuse the same resource-oriented API.
+`gitcode-api` is a community-maintained Python SDK for the GitCode REST API. It provides easy-to-use synchronous and asynchronous clients, repository-scoped helpers, and lightweight response models so you can work with GitCode from Python without hand-writing raw HTTP requests. The `gitcode_api.llm` module adds an OpenAI-style function tool, an MCP service, and an [openJiuwen](https://openjiuwen.com) tool integration so agents can reuse the same resource-oriented API.
 ## Why This Project
@@ -52,8 +52,9 @@ Dynamic: license-file
 - Resource groups such as `client.repos`, `client.pulls`, and `client.users`.
 - Repository defaults via `owner=` and `repo=` on the client.
 - Sphinx docs plus a mirrored GitCode REST API reference in `docs/`.
-- Provides MCP server & OpenAI tool for LLM agent usage.
+- Provides MCP server, OpenAI tool, and [openJiuwen](https://openjiuwen.com) tool for LLM agent usage.
 - Provide MCP service that directly installs to your IDE of choice, such as Cursor and VS Code!
+- Provides an [mcpb bundle](https://www.anthropic.com/engineering/desktop-extensions) you can install directly in the Claude desktop app; download it from [Release](https://github.com/Trenza1ore/GitCode-API/releases/latest).
 ## Installation
@@ -64,11 +65,11 @@ pip install -U gitcode-api
 ```
 Install the MCP server to your AI-powered IDE of choice:
 [![Install in Cursor](https://img.shields.io/badge/Install_in-Cursor-000000?style=flat-square&logoColor=white)](https://cursor.com/en/install-mcp?name=GitCode%20API&config=eyJjb21tYW5kIjoidXZ4IiwiYXJncyI6WyItLWZyb20iLCJnaXRjb2RlLWFwaVttY3BdIiwiZ2l0Y29kZS1hcGkiLCJzZXJ2ZSJdLCJlbnYiOnsiR0lUQ09ERV9BQ0NFU1NfVE9LRU4iOiIke2lucHV0OmdpdGNvZGVfYWNjZXNzX3Rva2VufSJ9LCJpbnB1dHMiOlt7ImlkIjoiZ2l0Y29kZV9hY2Nlc3NfdG9rZW4iLCJ0eXBlIjoicHJvbXB0U3RyaW5nIiwiZGVzY3JpcHRpb24iOiJFbnRlciBHSVRDT0RFX0FDQ0VTU19UT0tFTiIsInBhc3N3b3JkIjp0cnVlfV19)
 [![Install in VS Code](https://img.shields.io/badge/Install_in-VS_Code-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://vscode.dev/redirect/mcp/install?name=GitCode%20API&config=%7B%22command%22%3A%22uvx%22%2C%22args%22%3A%5B%22--from%22%2C%22gitcode-api%5Bmcp%5D%22%2C%22gitcode-api%22%2C%22serve%22%5D%2C%22env%22%3A%7B%22GITCODE_ACCESS_TOKEN%22%3A%22%24%7Binput%3Agitcode_access_token%7D%22%7D%2C%22inputs%22%3A%5B%7B%22id%22%3A%22gitcode_access_token%22%2C%22type%22%3A%22promptString%22%2C%22description%22%3A%22Enter%20GITCODE_ACCESS_TOKEN%22%2C%22password%22%3Atrue%7D%5D%7D)
 [![Install in VS Code Insiders](https://img.shields.io/badge/Install_in-VS_Code_Insiders-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=GitCode%20API&config=%7B%22command%22%3A%22uvx%22%2C%22args%22%3A%5B%22--from%22%2C%22gitcode-api%5Bmcp%5D%22%2C%22gitcode-api%22%2C%22serve%22%5D%2C%22env%22%3A%7B%22GITCODE_ACCESS_TOKEN%22%3A%22%24%7Binput%3Agitcode_access_token%7D%22%7D%2C%22inputs%22%3A%5B%7B%22id%22%3A%22gitcode_access_token%22%2C%22type%22%3A%22promptString%22%2C%22description%22%3A%22Enter%20GITCODE_ACCESS_TOKEN%22%2C%22password%22%3Atrue%7D%5D%7D&quality=insiders)
 [![Install in Visual Studio](https://img.shields.io/badge/Install_in-Visual_Studio-C16FDE?style=flat-square&logo=visualstudio&logoColor=white)](https://vs-open.link/mcp-install?%7B%22command%22%3A%22uvx%22%2C%22args%22%3A%5B%22--from%22%2C%22gitcode-api%5Bmcp%5D%22%2C%22gitcode-api%22%2C%22serve%22%5D%2C%22env%22%3A%7B%22GITCODE_ACCESS_TOKEN%22%3A%22%24%7Binput%3Agitcode_access_token%7D%22%7D%2C%22inputs%22%3A%5B%7B%22id%22%3A%22gitcode_access_token%22%2C%22type%22%3A%22promptString%22%2C%22description%22%3A%22Enter%20GITCODE_ACCESS_TOKEN%22%2C%22password%22%3Atrue%7D%5D%7D)
-[![Install in Goose](https://block.github.io/goose/img/extension-install-dark.svg)](https://block.github.io/goose/extension?cmd=uvx&arg=--from%2520gitcode-api%5Bmcp%5D%2520gitcode-api%2520serve&id=GitCode%20API&name=GitCode%20API&description=MCP%20Server%20for%20GitCode%20API)
 [![Add MCP Server GitCode API to LM Studio](https://files.lmstudio.ai/deeplink/mcp-install-light.svg)](https://lmstudio.ai/install-mcp?name=GitCode%20API&config=eyJjb21tYW5kIjoidXZ4IiwiYXJncyI6WyItLWZyb20iLCJnaXRjb2RlLWFwaVttY3BdIiwiZ2l0Y29kZS1hcGkiLCJzZXJ2ZSJdLCJlbnYiOnsiR0lUQ09ERV9BQ0NFU1NfVE9LRU4iOiIke2lucHV0OmdpdGNvZGVfYWNjZXNzX3Rva2VufSJ9LCJpbnB1dHMiOlt7ImlkIjoiZ2l0Y29kZV9hY2Nlc3NfdG9rZW4iLCJ0eXBlIjoicHJvbXB0U3RyaW5nIiwiZGVzY3JpcHRpb24iOiJFbnRlciBHSVRDT0RFX0FDQ0VTU19UT0tFTiIsInBhc3N3b3JkIjp0cnVlfV19)
 For detailed setup (including installing to services like Claude Code / Codex): see [install_mcp_server.md](install_mcp_server.md).
@@ -228,7 +229,7 @@ Both `GitCode` and `AsyncGitCode` expose:
 Every resource group inherits a cached `methods` property from the shared resource base: a `tuple` of public callable names in stable SDK order (underscore-segment sort key, not plain A–Z on the full identifier). Private names and the introspection helpers `methods` and `method_signature` are omitted. For example, `client.pulls.methods` helps with discovery or tooling without reading the full manual list. For one method’s parameters and return type, call `client.pulls.method_signature("list_issues")` (a cached string from `inspect.signature`, with `gitcode_api._models.` stripped from annotations).
-## LLM tools and MCP
+## 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:
@@ -239,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
@@ -264,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):
@@ -315,6 +326,24 @@ The same server is available from the CLI as `gitcode-api serve` (see the [CLI](
 To share auth or clients across tools, build `GitCodeLLMTool` once (`from gitcode_api.llm._tool import GitCodeLLMTool`) and pass it as `tool=` into `GitCodeMCP`, `create_mcp_server`, `register_mcp_gitcode_api_tool`, or `create_mcp_gitcode_api_tool`.
+### openJiuwen (`LocalFunction`)
+[openJiuwen](https://openjiuwen.com) is an open agent platform. With the separate `openjiuwen` package installed (**Python 3.11+**), `create_openjiuwen_gitcode_api_tool` returns an openJiuwen `LocalFunction` that uses the same `op_type` / `action` / `params` / `help` arguments as the OpenAI adapter. Invocation is async-only (`await jiuwen_tool.invoke({...})`).
+```bash
+pip install openjiuwen
+```
+```python
+from gitcode_api.llm import create_openjiuwen_gitcode_api_tool
+jiuwen_tool = create_openjiuwen_gitcode_api_tool(owner="SushiNinja", repo="GitCode-API")
+# jiuwen_tool.card — name, description, input_params
+# await jiuwen_tool.invoke({"op_type": "repos", "action": "get", "params": {}})
+```
+Optional `name=` and `description=` override the default tool card. Constructor options otherwise mirror `GitCode` / `AsyncGitCode` (`client=`, `async_client=`, `api_key=`, `owner=`, `repo=`, `base_url=`, `timeout=`, `decrypt=`).
 **Claude Desktop (MCPB):** published GitHub Releases include a `gitcode-<version>.mcpb` bundle for one-click installation as a Claude Desktop extension; see Anthropic’s guide, [Build a desktop extension with MCPB](https://claude.com/docs/connectors/building/mcpb). From a checkout you can run `make mcpb` (requires the [`@anthropic-ai/mcpb`](https://www.npmjs.com/package/@anthropic-ai/mcpb) CLI on your `PATH`).
 ## Examples
@@ -378,7 +407,7 @@ with GitCode(
 Use `httpx.AsyncClient(verify=...)` with `AsyncGitCode` for async code.
-The OpenAI tool (`GitCodeOpenAITool`) and MCP helpers accept the same `client=` / `async_client=` arguments (or a shared `GitCodeLLMTool` via `tool=` with those clients set). Build `GitCode` / `AsyncGitCode` with your custom `http_client` once and pass it through so LLM tool calls reuse the same TLS settings.
+The OpenAI tool (`GitCodeOpenAITool`), MCP helpers, and `create_openjiuwen_gitcode_api_tool` accept the same `client=` / `async_client=` arguments (OpenAI and MCP also accept a shared `GitCodeLLMTool` via `tool=`). Build `GitCode` / `AsyncGitCode` with your custom `http_client` once and pass it through so LLM tool calls reuse the same TLS settings.
 ## Project Status

{gitcode_api-1.2.8 → gitcode_api-1.2.10}/README.md RENAMED Viewed

@@ -1,12 +1,12 @@
 # GitCode-API
 [![PyPI - Version](https://img.shields.io/pypi/v/gitcode-api?link=https%3A%2F%2Fpypi.org%2Fproject%2Fgitcode-api%2F)](https://pypi.org/project/gitcode-api) [![PyPI Downloads](https://static.pepy.tech/personalized-badge/gitcode-api?period=total&units=INTERNATIONAL_SYSTEM&left_color=GRAY&right_color=RED&left_text=downloads)](https://pepy.tech/projects/gitcode-api) [![CodeFactor](https://www.codefactor.io/repository/github/trenza1ore/gitcode-api/badge)](https://www.codefactor.io/repository/github/trenza1ore/gitcode-api)
-[![Install in Cursor](https://img.shields.io/badge/Install_in-Cursor-000000?style=flat-square&logoColor=white)](https://cursor.com/en/install-mcp?name=GitCode%20API&config=eyJjb21tYW5kIjoidXZ4IiwiYXJncyI6WyItLWZyb20iLCJnaXRjb2RlLWFwaVttY3BdIiwiZ2l0Y29kZS1hcGkiLCJzZXJ2ZSJdLCJlbnYiOnsiR0lUQ09ERV9BQ0NFU1NfVE9LRU4iOiIke2lucHV0OmdpdGNvZGVfYWNjZXNzX3Rva2VufSJ9LCJpbnB1dHMiOlt7ImlkIjoiZ2l0Y29kZV9hY2Nlc3NfdG9rZW4iLCJ0eXBlIjoicHJvbXB0U3RyaW5nIiwiZGVzY3JpcHRpb24iOiJFbnRlciBHSVRDT0RFX0FDQ0VTU19UT0tFTiIsInBhc3N3b3JkIjp0cnVlfV19) [![Install in VS Code](https://img.shields.io/badge/Install_in-VS_Code-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://vscode.dev/redirect/mcp/install?name=GitCode%20API&config=%7B%22command%22%3A%22uvx%22%2C%22args%22%3A%5B%22--from%22%2C%22gitcode-api%5Bmcp%5D%22%2C%22gitcode-api%22%2C%22serve%22%5D%2C%22env%22%3A%7B%22GITCODE_ACCESS_TOKEN%22%3A%22%24%7Binput%3Agitcode_access_token%7D%22%7D%2C%22inputs%22%3A%5B%7B%22id%22%3A%22gitcode_access_token%22%2C%22type%22%3A%22promptString%22%2C%22description%22%3A%22Enter%20GITCODE_ACCESS_TOKEN%22%2C%22password%22%3Atrue%7D%5D%7D)
+[![Install in Cursor](https://img.shields.io/badge/Install_in-Cursor-000000?logoColor=white)](https://cursor.com/en/install-mcp?name=GitCode%20API&config=eyJjb21tYW5kIjoidXZ4IiwiYXJncyI6WyItLWZyb20iLCJnaXRjb2RlLWFwaVttY3BdIiwiZ2l0Y29kZS1hcGkiLCJzZXJ2ZSJdLCJlbnYiOnsiR0lUQ09ERV9BQ0NFU1NfVE9LRU4iOiIke2lucHV0OmdpdGNvZGVfYWNjZXNzX3Rva2VufSJ9LCJpbnB1dHMiOlt7ImlkIjoiZ2l0Y29kZV9hY2Nlc3NfdG9rZW4iLCJ0eXBlIjoicHJvbXB0U3RyaW5nIiwiZGVzY3JpcHRpb24iOiJFbnRlciBHSVRDT0RFX0FDQ0VTU19UT0tFTiIsInBhc3N3b3JkIjp0cnVlfV19) [![Install in VS Code](https://img.shields.io/badge/Install_in-VS_Code-0098FF?logo=visualstudiocode&logoColor=white)](https://vscode.dev/redirect/mcp/install?name=GitCode%20API&config=%7B%22command%22%3A%22uvx%22%2C%22args%22%3A%5B%22--from%22%2C%22gitcode-api%5Bmcp%5D%22%2C%22gitcode-api%22%2C%22serve%22%5D%2C%22env%22%3A%7B%22GITCODE_ACCESS_TOKEN%22%3A%22%24%7Binput%3Agitcode_access_token%7D%22%7D%2C%22inputs%22%3A%5B%7B%22id%22%3A%22gitcode_access_token%22%2C%22type%22%3A%22promptString%22%2C%22description%22%3A%22Enter%20GITCODE_ACCESS_TOKEN%22%2C%22password%22%3Atrue%7D%5D%7D)
 [![GitHub Badge](https://img.shields.io/badge/github-repo-blue?logo=github&link=https%3A%2F%2Fgithub.com%2FTrenza1ore%2FGitCode-API)](https://github.com/Trenza1ore/GitCode-API) [![GitCode Badge](https://img.shields.io/badge/gitcode-repo-brown?logo=gitcode&link=https%3A%2F%2Fgitcode.com%2FSushiNinja%2FGitCode-API)](https://gitcode.com/SushiNinja/GitCode-API)
 [![Docs](https://img.shields.io/badge/%E6%96%87%E6%A1%A3-Docs-cyan?style=for-the-badge&logo=readthedocs&link=https%3A%2F%2Fgitcode-api.readthedocs.io%2Fen%2Flatest%2Findex.html)](https://gitcode-api.readthedocs.io) [![中文README](https://img.shields.io/badge/%E4%B8%AD%E6%96%87-README-brown?style=for-the-badge&logo=googledocs&link=README.zh.md)](README.zh.md)
-`gitcode-api` is a community-maintained Python SDK for the GitCode REST API. It provides easy-to-use synchronous and asynchronous clients, repository-scoped helpers, and lightweight response models so you can work with GitCode from Python without hand-writing raw HTTP requests. The `gitcode_api.llm` module adds an OpenAI-style function tool and MCP service so agents can reuse the same resource-oriented API.
+`gitcode-api` is a community-maintained Python SDK for the GitCode REST API. It provides easy-to-use synchronous and asynchronous clients, repository-scoped helpers, and lightweight response models so you can work with GitCode from Python without hand-writing raw HTTP requests. The `gitcode_api.llm` module adds an OpenAI-style function tool, an MCP service, and an [openJiuwen](https://openjiuwen.com) tool integration so agents can reuse the same resource-oriented API.
 ## Why This Project
@@ -15,8 +15,9 @@
 - Resource groups such as `client.repos`, `client.pulls`, and `client.users`.
 - Repository defaults via `owner=` and `repo=` on the client.
 - Sphinx docs plus a mirrored GitCode REST API reference in `docs/`.
-- Provides MCP server & OpenAI tool for LLM agent usage.
+- Provides MCP server, OpenAI tool, and [openJiuwen](https://openjiuwen.com) tool for LLM agent usage.
 - Provide MCP service that directly installs to your IDE of choice, such as Cursor and VS Code!
+- Provides an [mcpb bundle](https://www.anthropic.com/engineering/desktop-extensions) you can install directly in the Claude desktop app; download it from [Release](https://github.com/Trenza1ore/GitCode-API/releases/latest).
 ## Installation
@@ -27,11 +28,11 @@ pip install -U gitcode-api
 ```
 Install the MCP server to your AI-powered IDE of choice:
 [![Install in Cursor](https://img.shields.io/badge/Install_in-Cursor-000000?style=flat-square&logoColor=white)](https://cursor.com/en/install-mcp?name=GitCode%20API&config=eyJjb21tYW5kIjoidXZ4IiwiYXJncyI6WyItLWZyb20iLCJnaXRjb2RlLWFwaVttY3BdIiwiZ2l0Y29kZS1hcGkiLCJzZXJ2ZSJdLCJlbnYiOnsiR0lUQ09ERV9BQ0NFU1NfVE9LRU4iOiIke2lucHV0OmdpdGNvZGVfYWNjZXNzX3Rva2VufSJ9LCJpbnB1dHMiOlt7ImlkIjoiZ2l0Y29kZV9hY2Nlc3NfdG9rZW4iLCJ0eXBlIjoicHJvbXB0U3RyaW5nIiwiZGVzY3JpcHRpb24iOiJFbnRlciBHSVRDT0RFX0FDQ0VTU19UT0tFTiIsInBhc3N3b3JkIjp0cnVlfV19)
 [![Install in VS Code](https://img.shields.io/badge/Install_in-VS_Code-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://vscode.dev/redirect/mcp/install?name=GitCode%20API&config=%7B%22command%22%3A%22uvx%22%2C%22args%22%3A%5B%22--from%22%2C%22gitcode-api%5Bmcp%5D%22%2C%22gitcode-api%22%2C%22serve%22%5D%2C%22env%22%3A%7B%22GITCODE_ACCESS_TOKEN%22%3A%22%24%7Binput%3Agitcode_access_token%7D%22%7D%2C%22inputs%22%3A%5B%7B%22id%22%3A%22gitcode_access_token%22%2C%22type%22%3A%22promptString%22%2C%22description%22%3A%22Enter%20GITCODE_ACCESS_TOKEN%22%2C%22password%22%3Atrue%7D%5D%7D)
 [![Install in VS Code Insiders](https://img.shields.io/badge/Install_in-VS_Code_Insiders-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=GitCode%20API&config=%7B%22command%22%3A%22uvx%22%2C%22args%22%3A%5B%22--from%22%2C%22gitcode-api%5Bmcp%5D%22%2C%22gitcode-api%22%2C%22serve%22%5D%2C%22env%22%3A%7B%22GITCODE_ACCESS_TOKEN%22%3A%22%24%7Binput%3Agitcode_access_token%7D%22%7D%2C%22inputs%22%3A%5B%7B%22id%22%3A%22gitcode_access_token%22%2C%22type%22%3A%22promptString%22%2C%22description%22%3A%22Enter%20GITCODE_ACCESS_TOKEN%22%2C%22password%22%3Atrue%7D%5D%7D&quality=insiders)
 [![Install in Visual Studio](https://img.shields.io/badge/Install_in-Visual_Studio-C16FDE?style=flat-square&logo=visualstudio&logoColor=white)](https://vs-open.link/mcp-install?%7B%22command%22%3A%22uvx%22%2C%22args%22%3A%5B%22--from%22%2C%22gitcode-api%5Bmcp%5D%22%2C%22gitcode-api%22%2C%22serve%22%5D%2C%22env%22%3A%7B%22GITCODE_ACCESS_TOKEN%22%3A%22%24%7Binput%3Agitcode_access_token%7D%22%7D%2C%22inputs%22%3A%5B%7B%22id%22%3A%22gitcode_access_token%22%2C%22type%22%3A%22promptString%22%2C%22description%22%3A%22Enter%20GITCODE_ACCESS_TOKEN%22%2C%22password%22%3Atrue%7D%5D%7D)
-[![Install in Goose](https://block.github.io/goose/img/extension-install-dark.svg)](https://block.github.io/goose/extension?cmd=uvx&arg=--from%2520gitcode-api%5Bmcp%5D%2520gitcode-api%2520serve&id=GitCode%20API&name=GitCode%20API&description=MCP%20Server%20for%20GitCode%20API)
 [![Add MCP Server GitCode API to LM Studio](https://files.lmstudio.ai/deeplink/mcp-install-light.svg)](https://lmstudio.ai/install-mcp?name=GitCode%20API&config=eyJjb21tYW5kIjoidXZ4IiwiYXJncyI6WyItLWZyb20iLCJnaXRjb2RlLWFwaVttY3BdIiwiZ2l0Y29kZS1hcGkiLCJzZXJ2ZSJdLCJlbnYiOnsiR0lUQ09ERV9BQ0NFU1NfVE9LRU4iOiIke2lucHV0OmdpdGNvZGVfYWNjZXNzX3Rva2VufSJ9LCJpbnB1dHMiOlt7ImlkIjoiZ2l0Y29kZV9hY2Nlc3NfdG9rZW4iLCJ0eXBlIjoicHJvbXB0U3RyaW5nIiwiZGVzY3JpcHRpb24iOiJFbnRlciBHSVRDT0RFX0FDQ0VTU19UT0tFTiIsInBhc3N3b3JkIjp0cnVlfV19)
 For detailed setup (including installing to services like Claude Code / Codex): see [install_mcp_server.md](install_mcp_server.md).
@@ -191,7 +192,7 @@ Both `GitCode` and `AsyncGitCode` expose:
 Every resource group inherits a cached `methods` property from the shared resource base: a `tuple` of public callable names in stable SDK order (underscore-segment sort key, not plain A–Z on the full identifier). Private names and the introspection helpers `methods` and `method_signature` are omitted. For example, `client.pulls.methods` helps with discovery or tooling without reading the full manual list. For one method’s parameters and return type, call `client.pulls.method_signature("list_issues")` (a cached string from `inspect.signature`, with `gitcode_api._models.` stripped from annotations).
-## LLM tools and MCP
+## 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:
@@ -202,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
@@ -227,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):
@@ -278,6 +289,24 @@ The same server is available from the CLI as `gitcode-api serve` (see the [CLI](
 To share auth or clients across tools, build `GitCodeLLMTool` once (`from gitcode_api.llm._tool import GitCodeLLMTool`) and pass it as `tool=` into `GitCodeMCP`, `create_mcp_server`, `register_mcp_gitcode_api_tool`, or `create_mcp_gitcode_api_tool`.
+### openJiuwen (`LocalFunction`)
+[openJiuwen](https://openjiuwen.com) is an open agent platform. With the separate `openjiuwen` package installed (**Python 3.11+**), `create_openjiuwen_gitcode_api_tool` returns an openJiuwen `LocalFunction` that uses the same `op_type` / `action` / `params` / `help` arguments as the OpenAI adapter. Invocation is async-only (`await jiuwen_tool.invoke({...})`).
+```bash
+pip install openjiuwen
+```
+```python
+from gitcode_api.llm import create_openjiuwen_gitcode_api_tool
+jiuwen_tool = create_openjiuwen_gitcode_api_tool(owner="SushiNinja", repo="GitCode-API")
+# jiuwen_tool.card — name, description, input_params
+# await jiuwen_tool.invoke({"op_type": "repos", "action": "get", "params": {}})
+```
+Optional `name=` and `description=` override the default tool card. Constructor options otherwise mirror `GitCode` / `AsyncGitCode` (`client=`, `async_client=`, `api_key=`, `owner=`, `repo=`, `base_url=`, `timeout=`, `decrypt=`).
 **Claude Desktop (MCPB):** published GitHub Releases include a `gitcode-<version>.mcpb` bundle for one-click installation as a Claude Desktop extension; see Anthropic’s guide, [Build a desktop extension with MCPB](https://claude.com/docs/connectors/building/mcpb). From a checkout you can run `make mcpb` (requires the [`@anthropic-ai/mcpb`](https://www.npmjs.com/package/@anthropic-ai/mcpb) CLI on your `PATH`).
 ## Examples
@@ -341,7 +370,7 @@ with GitCode(
 Use `httpx.AsyncClient(verify=...)` with `AsyncGitCode` for async code.
-The OpenAI tool (`GitCodeOpenAITool`) and MCP helpers accept the same `client=` / `async_client=` arguments (or a shared `GitCodeLLMTool` via `tool=` with those clients set). Build `GitCode` / `AsyncGitCode` with your custom `http_client` once and pass it through so LLM tool calls reuse the same TLS settings.
+The OpenAI tool (`GitCodeOpenAITool`), MCP helpers, and `create_openjiuwen_gitcode_api_tool` accept the same `client=` / `async_client=` arguments (OpenAI and MCP also accept a shared `GitCodeLLMTool` via `tool=`). Build `GitCode` / `AsyncGitCode` with your custom `http_client` once and pass it through so LLM tool calls reuse the same TLS settings.
 ## Project Status

{gitcode_api-1.2.8 → gitcode_api-1.2.10}/gitcode_api/llm/__init__.py RENAMED Viewed

@@ -4,6 +4,7 @@ from importlib import import_module
 from typing import TYPE_CHECKING, Any, Dict
 if TYPE_CHECKING:
+    from .jiuwen import create_openjiuwen_gitcode_api_tool
     from .mcp import (
         GitCodeMCP,
         create_mcp_gitcode_api_tool,
@@ -21,6 +22,7 @@ _IMPORT_MAP = {
     "register_mcp_gitcode_api_tool": ".mcp",
     "register_mcp_help_resources": ".mcp",
     "GitCodeOpenAITool": ".openai",
+    "create_openjiuwen_gitcode_api_tool": ".jiuwen",
 }
 _IMPORT_CACHE: Dict[str, Any] = {}
@@ -54,4 +56,5 @@ __all__ = [
     "create_mcp_server",
     "register_mcp_gitcode_api_tool",
     "register_mcp_help_resources",
+    "create_openjiuwen_gitcode_api_tool",
 ]

gitcode_api-1.2.10/gitcode_api/llm/jiuwen.py ADDED Viewed

@@ -0,0 +1,98 @@
+"""openJiuwen ``LocalFunction`` adapter for the GitCode LLM tool."""
+from importlib import import_module
+from typing import TYPE_CHECKING, Any, Callable, Dict, Optional
+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
+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. "
+        "Note: Python 3.11+ is required for openjiuwen."
+    )
+def _openjiuwen_tool_decorator() -> Callable[..., Any]:
+    try:
+        mod = import_module("openjiuwen.core.foundation.tool")
+    except ImportError as exc:
+        raise _missing_openjiuwen_error() from exc
+    return getattr(mod, "tool")  # type: ignore[no-any-return]
+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)
+        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()
+        async def _async_impl(
+            op_type: str,
+            action: str = "",
+            params: Optional[Dict[str, Any]] = None,
+            help: bool = False,
+        ) -> Any:
+            return await self.__async_call__(op_type=op_type, action=action, params=params, help=help)
+        self.local_function = oj_tool(
+            _async_impl,
+            name=tool_name,
+            description=tool_description,
+            input_params=TOOL_PARAMETERS,
+            auto_extract=False,
+        )
+def create_openjiuwen_gitcode_api_tool(
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+    *,
+    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,
+) -> "LocalFunction":
+    """Create an openJiuwen ``LocalFunction`` for the GitCode API tool.
+    :param name: Tool name on the ``LocalFunction`` card; defaults to ``gitcode_api_tool``.
+    :param description: Tool description on the card; defaults to the shared GitCode tool description.
+    :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.
+    :returns: openJiuwen ``LocalFunction`` with the standard parameter schema.
+    """
+    adapter = _GitCodeJiuwenTool(
+        client=client,
+        async_client=async_client,
+        api_key=api_key,
+        owner=owner,
+        repo=repo,
+        base_url=base_url,
+        timeout=timeout,
+        decrypt=decrypt,
+        name=name,
+        description=description,
+    )
+    return adapter.local_function
+__all__ = ["create_openjiuwen_gitcode_api_tool"]

{gitcode_api-1.2.8 → gitcode_api-1.2.10}/gitcode_api/llm/openai.py RENAMED Viewed

@@ -1,7 +1,8 @@
 """OpenAI tool adapter for the GitCode SDK."""
+import json
 from functools import cached_property
-from typing import Any, Dict, Optional
+from typing import Any, Coroutine, Dict, Union
 from ._tool import TOOL_DESCRIPTION, TOOL_NAME, TOOL_PARAMETERS, GitCodeLLMTool
@@ -10,25 +11,21 @@ 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.
+    :param indent: ``indent`` argument passed to :func:`json.dumps` when serializing
+        invocation results (default ``2``).
+    :param kwargs: Passed to :class:`gitcode_api.llm.GitCodeLLMTool` ---
+        ``client``, ``async_client``, ``api_key``, ``owner``, ``repo``, ``base_url``, ``timeout``, ``decrypt``.
     """
     name = TOOL_NAME
     description = TOOL_DESCRIPTION
     parameters = TOOL_PARAMETERS
-    def __init__(self, async_mode: Optional[bool] = None, **kwargs) -> None:
+    def __init__(self, async_mode: bool = False, indent: int = 2, **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.indent = indent
         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]:
@@ -46,11 +43,15 @@ class GitCodeOpenAITool(GitCodeLLMTool):
         """Return this tool in OpenAI Chat Completions tool format."""
         return self.tool
-    def __call__(self, *args: Any, **kwargs) -> Any:
+    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 super().__call__(*args, **kwargs)
+        return json.dumps(super().__call__(*args, **kwargs), ensure_ascii=False, indent=self.indent)
 __all__ = ["GitCodeOpenAITool"]

gitcode_api-1.2.10/gitcode_api/version.txt ADDED Viewed

	@@ -0,0 +1 @@
1	+ 1.2.10

{gitcode_api-1.2.8 → gitcode_api-1.2.10}/gitcode_api.egg-info/PKG-INFO RENAMED Viewed

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: gitcode-api
-Version: 1.2.8
-Summary: Easy to use Python SDK for the GitCode REST API. Providing builtin CLI tool, and optional LLM integration (MCP and OpenAI tool) for agents. Community-maintained.
+Version: 1.2.10
+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
 Project-URL: changelog, https://gitcode-api.readthedocs.io/en/latest/changelog.html
@@ -11,7 +11,7 @@ Project-URL: gitcode, https://gitcode.com/SushiNinja/GitCode-API
 Project-URL: github, https://github.com/Trenza1ore/GitCode-API
 Project-URL: homepage, https://linktr.ee/Hugoooo
 Project-URL: author, https://hugohuang.com
-Keywords: gitcode,git,devops,api,sdk,python,httpx,client,mcp,agent,fastmcp,llm,mcp client,mcp server,model context protocol
+Keywords: gitcode,git,devops,api,sdk,python,httpx,client,mcp,agent,fastmcp,llm,openjiuwen,mcp client,mcp server,model context protocol
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: Implementation :: CPython
@@ -38,12 +38,12 @@ Dynamic: license-file
 # GitCode-API
 [![PyPI - Version](https://img.shields.io/pypi/v/gitcode-api?link=https%3A%2F%2Fpypi.org%2Fproject%2Fgitcode-api%2F)](https://pypi.org/project/gitcode-api) [![PyPI Downloads](https://static.pepy.tech/personalized-badge/gitcode-api?period=total&units=INTERNATIONAL_SYSTEM&left_color=GRAY&right_color=RED&left_text=downloads)](https://pepy.tech/projects/gitcode-api) [![CodeFactor](https://www.codefactor.io/repository/github/trenza1ore/gitcode-api/badge)](https://www.codefactor.io/repository/github/trenza1ore/gitcode-api)
-[![Install in Cursor](https://img.shields.io/badge/Install_in-Cursor-000000?style=flat-square&logoColor=white)](https://cursor.com/en/install-mcp?name=GitCode%20API&config=eyJjb21tYW5kIjoidXZ4IiwiYXJncyI6WyItLWZyb20iLCJnaXRjb2RlLWFwaVttY3BdIiwiZ2l0Y29kZS1hcGkiLCJzZXJ2ZSJdLCJlbnYiOnsiR0lUQ09ERV9BQ0NFU1NfVE9LRU4iOiIke2lucHV0OmdpdGNvZGVfYWNjZXNzX3Rva2VufSJ9LCJpbnB1dHMiOlt7ImlkIjoiZ2l0Y29kZV9hY2Nlc3NfdG9rZW4iLCJ0eXBlIjoicHJvbXB0U3RyaW5nIiwiZGVzY3JpcHRpb24iOiJFbnRlciBHSVRDT0RFX0FDQ0VTU19UT0tFTiIsInBhc3N3b3JkIjp0cnVlfV19) [![Install in VS Code](https://img.shields.io/badge/Install_in-VS_Code-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://vscode.dev/redirect/mcp/install?name=GitCode%20API&config=%7B%22command%22%3A%22uvx%22%2C%22args%22%3A%5B%22--from%22%2C%22gitcode-api%5Bmcp%5D%22%2C%22gitcode-api%22%2C%22serve%22%5D%2C%22env%22%3A%7B%22GITCODE_ACCESS_TOKEN%22%3A%22%24%7Binput%3Agitcode_access_token%7D%22%7D%2C%22inputs%22%3A%5B%7B%22id%22%3A%22gitcode_access_token%22%2C%22type%22%3A%22promptString%22%2C%22description%22%3A%22Enter%20GITCODE_ACCESS_TOKEN%22%2C%22password%22%3Atrue%7D%5D%7D)
+[![Install in Cursor](https://img.shields.io/badge/Install_in-Cursor-000000?logoColor=white)](https://cursor.com/en/install-mcp?name=GitCode%20API&config=eyJjb21tYW5kIjoidXZ4IiwiYXJncyI6WyItLWZyb20iLCJnaXRjb2RlLWFwaVttY3BdIiwiZ2l0Y29kZS1hcGkiLCJzZXJ2ZSJdLCJlbnYiOnsiR0lUQ09ERV9BQ0NFU1NfVE9LRU4iOiIke2lucHV0OmdpdGNvZGVfYWNjZXNzX3Rva2VufSJ9LCJpbnB1dHMiOlt7ImlkIjoiZ2l0Y29kZV9hY2Nlc3NfdG9rZW4iLCJ0eXBlIjoicHJvbXB0U3RyaW5nIiwiZGVzY3JpcHRpb24iOiJFbnRlciBHSVRDT0RFX0FDQ0VTU19UT0tFTiIsInBhc3N3b3JkIjp0cnVlfV19) [![Install in VS Code](https://img.shields.io/badge/Install_in-VS_Code-0098FF?logo=visualstudiocode&logoColor=white)](https://vscode.dev/redirect/mcp/install?name=GitCode%20API&config=%7B%22command%22%3A%22uvx%22%2C%22args%22%3A%5B%22--from%22%2C%22gitcode-api%5Bmcp%5D%22%2C%22gitcode-api%22%2C%22serve%22%5D%2C%22env%22%3A%7B%22GITCODE_ACCESS_TOKEN%22%3A%22%24%7Binput%3Agitcode_access_token%7D%22%7D%2C%22inputs%22%3A%5B%7B%22id%22%3A%22gitcode_access_token%22%2C%22type%22%3A%22promptString%22%2C%22description%22%3A%22Enter%20GITCODE_ACCESS_TOKEN%22%2C%22password%22%3Atrue%7D%5D%7D)
 [![GitHub Badge](https://img.shields.io/badge/github-repo-blue?logo=github&link=https%3A%2F%2Fgithub.com%2FTrenza1ore%2FGitCode-API)](https://github.com/Trenza1ore/GitCode-API) [![GitCode Badge](https://img.shields.io/badge/gitcode-repo-brown?logo=gitcode&link=https%3A%2F%2Fgitcode.com%2FSushiNinja%2FGitCode-API)](https://gitcode.com/SushiNinja/GitCode-API)
 [![Docs](https://img.shields.io/badge/%E6%96%87%E6%A1%A3-Docs-cyan?style=for-the-badge&logo=readthedocs&link=https%3A%2F%2Fgitcode-api.readthedocs.io%2Fen%2Flatest%2Findex.html)](https://gitcode-api.readthedocs.io) [![中文README](https://img.shields.io/badge/%E4%B8%AD%E6%96%87-README-brown?style=for-the-badge&logo=googledocs&link=README.zh.md)](README.zh.md)
-`gitcode-api` is a community-maintained Python SDK for the GitCode REST API. It provides easy-to-use synchronous and asynchronous clients, repository-scoped helpers, and lightweight response models so you can work with GitCode from Python without hand-writing raw HTTP requests. The `gitcode_api.llm` module adds an OpenAI-style function tool and MCP service so agents can reuse the same resource-oriented API.
+`gitcode-api` is a community-maintained Python SDK for the GitCode REST API. It provides easy-to-use synchronous and asynchronous clients, repository-scoped helpers, and lightweight response models so you can work with GitCode from Python without hand-writing raw HTTP requests. The `gitcode_api.llm` module adds an OpenAI-style function tool, an MCP service, and an [openJiuwen](https://openjiuwen.com) tool integration so agents can reuse the same resource-oriented API.
 ## Why This Project
@@ -52,8 +52,9 @@ Dynamic: license-file
 - Resource groups such as `client.repos`, `client.pulls`, and `client.users`.
 - Repository defaults via `owner=` and `repo=` on the client.
 - Sphinx docs plus a mirrored GitCode REST API reference in `docs/`.
-- Provides MCP server & OpenAI tool for LLM agent usage.
+- Provides MCP server, OpenAI tool, and [openJiuwen](https://openjiuwen.com) tool for LLM agent usage.
 - Provide MCP service that directly installs to your IDE of choice, such as Cursor and VS Code!
+- Provides an [mcpb bundle](https://www.anthropic.com/engineering/desktop-extensions) you can install directly in the Claude desktop app; download it from [Release](https://github.com/Trenza1ore/GitCode-API/releases/latest).
 ## Installation
@@ -64,11 +65,11 @@ pip install -U gitcode-api
 ```
 Install the MCP server to your AI-powered IDE of choice:
 [![Install in Cursor](https://img.shields.io/badge/Install_in-Cursor-000000?style=flat-square&logoColor=white)](https://cursor.com/en/install-mcp?name=GitCode%20API&config=eyJjb21tYW5kIjoidXZ4IiwiYXJncyI6WyItLWZyb20iLCJnaXRjb2RlLWFwaVttY3BdIiwiZ2l0Y29kZS1hcGkiLCJzZXJ2ZSJdLCJlbnYiOnsiR0lUQ09ERV9BQ0NFU1NfVE9LRU4iOiIke2lucHV0OmdpdGNvZGVfYWNjZXNzX3Rva2VufSJ9LCJpbnB1dHMiOlt7ImlkIjoiZ2l0Y29kZV9hY2Nlc3NfdG9rZW4iLCJ0eXBlIjoicHJvbXB0U3RyaW5nIiwiZGVzY3JpcHRpb24iOiJFbnRlciBHSVRDT0RFX0FDQ0VTU19UT0tFTiIsInBhc3N3b3JkIjp0cnVlfV19)
 [![Install in VS Code](https://img.shields.io/badge/Install_in-VS_Code-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://vscode.dev/redirect/mcp/install?name=GitCode%20API&config=%7B%22command%22%3A%22uvx%22%2C%22args%22%3A%5B%22--from%22%2C%22gitcode-api%5Bmcp%5D%22%2C%22gitcode-api%22%2C%22serve%22%5D%2C%22env%22%3A%7B%22GITCODE_ACCESS_TOKEN%22%3A%22%24%7Binput%3Agitcode_access_token%7D%22%7D%2C%22inputs%22%3A%5B%7B%22id%22%3A%22gitcode_access_token%22%2C%22type%22%3A%22promptString%22%2C%22description%22%3A%22Enter%20GITCODE_ACCESS_TOKEN%22%2C%22password%22%3Atrue%7D%5D%7D)
 [![Install in VS Code Insiders](https://img.shields.io/badge/Install_in-VS_Code_Insiders-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=GitCode%20API&config=%7B%22command%22%3A%22uvx%22%2C%22args%22%3A%5B%22--from%22%2C%22gitcode-api%5Bmcp%5D%22%2C%22gitcode-api%22%2C%22serve%22%5D%2C%22env%22%3A%7B%22GITCODE_ACCESS_TOKEN%22%3A%22%24%7Binput%3Agitcode_access_token%7D%22%7D%2C%22inputs%22%3A%5B%7B%22id%22%3A%22gitcode_access_token%22%2C%22type%22%3A%22promptString%22%2C%22description%22%3A%22Enter%20GITCODE_ACCESS_TOKEN%22%2C%22password%22%3Atrue%7D%5D%7D&quality=insiders)
 [![Install in Visual Studio](https://img.shields.io/badge/Install_in-Visual_Studio-C16FDE?style=flat-square&logo=visualstudio&logoColor=white)](https://vs-open.link/mcp-install?%7B%22command%22%3A%22uvx%22%2C%22args%22%3A%5B%22--from%22%2C%22gitcode-api%5Bmcp%5D%22%2C%22gitcode-api%22%2C%22serve%22%5D%2C%22env%22%3A%7B%22GITCODE_ACCESS_TOKEN%22%3A%22%24%7Binput%3Agitcode_access_token%7D%22%7D%2C%22inputs%22%3A%5B%7B%22id%22%3A%22gitcode_access_token%22%2C%22type%22%3A%22promptString%22%2C%22description%22%3A%22Enter%20GITCODE_ACCESS_TOKEN%22%2C%22password%22%3Atrue%7D%5D%7D)
-[![Install in Goose](https://block.github.io/goose/img/extension-install-dark.svg)](https://block.github.io/goose/extension?cmd=uvx&arg=--from%2520gitcode-api%5Bmcp%5D%2520gitcode-api%2520serve&id=GitCode%20API&name=GitCode%20API&description=MCP%20Server%20for%20GitCode%20API)
 [![Add MCP Server GitCode API to LM Studio](https://files.lmstudio.ai/deeplink/mcp-install-light.svg)](https://lmstudio.ai/install-mcp?name=GitCode%20API&config=eyJjb21tYW5kIjoidXZ4IiwiYXJncyI6WyItLWZyb20iLCJnaXRjb2RlLWFwaVttY3BdIiwiZ2l0Y29kZS1hcGkiLCJzZXJ2ZSJdLCJlbnYiOnsiR0lUQ09ERV9BQ0NFU1NfVE9LRU4iOiIke2lucHV0OmdpdGNvZGVfYWNjZXNzX3Rva2VufSJ9LCJpbnB1dHMiOlt7ImlkIjoiZ2l0Y29kZV9hY2Nlc3NfdG9rZW4iLCJ0eXBlIjoicHJvbXB0U3RyaW5nIiwiZGVzY3JpcHRpb24iOiJFbnRlciBHSVRDT0RFX0FDQ0VTU19UT0tFTiIsInBhc3N3b3JkIjp0cnVlfV19)
 For detailed setup (including installing to services like Claude Code / Codex): see [install_mcp_server.md](install_mcp_server.md).
@@ -228,7 +229,7 @@ Both `GitCode` and `AsyncGitCode` expose:
 Every resource group inherits a cached `methods` property from the shared resource base: a `tuple` of public callable names in stable SDK order (underscore-segment sort key, not plain A–Z on the full identifier). Private names and the introspection helpers `methods` and `method_signature` are omitted. For example, `client.pulls.methods` helps with discovery or tooling without reading the full manual list. For one method’s parameters and return type, call `client.pulls.method_signature("list_issues")` (a cached string from `inspect.signature`, with `gitcode_api._models.` stripped from annotations).
-## LLM tools and MCP
+## 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:
@@ -239,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
@@ -264,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):
@@ -315,6 +326,24 @@ The same server is available from the CLI as `gitcode-api serve` (see the [CLI](
 To share auth or clients across tools, build `GitCodeLLMTool` once (`from gitcode_api.llm._tool import GitCodeLLMTool`) and pass it as `tool=` into `GitCodeMCP`, `create_mcp_server`, `register_mcp_gitcode_api_tool`, or `create_mcp_gitcode_api_tool`.
+### openJiuwen (`LocalFunction`)
+[openJiuwen](https://openjiuwen.com) is an open agent platform. With the separate `openjiuwen` package installed (**Python 3.11+**), `create_openjiuwen_gitcode_api_tool` returns an openJiuwen `LocalFunction` that uses the same `op_type` / `action` / `params` / `help` arguments as the OpenAI adapter. Invocation is async-only (`await jiuwen_tool.invoke({...})`).
+```bash
+pip install openjiuwen
+```
+```python
+from gitcode_api.llm import create_openjiuwen_gitcode_api_tool
+jiuwen_tool = create_openjiuwen_gitcode_api_tool(owner="SushiNinja", repo="GitCode-API")
+# jiuwen_tool.card — name, description, input_params
+# await jiuwen_tool.invoke({"op_type": "repos", "action": "get", "params": {}})
+```
+Optional `name=` and `description=` override the default tool card. Constructor options otherwise mirror `GitCode` / `AsyncGitCode` (`client=`, `async_client=`, `api_key=`, `owner=`, `repo=`, `base_url=`, `timeout=`, `decrypt=`).
 **Claude Desktop (MCPB):** published GitHub Releases include a `gitcode-<version>.mcpb` bundle for one-click installation as a Claude Desktop extension; see Anthropic’s guide, [Build a desktop extension with MCPB](https://claude.com/docs/connectors/building/mcpb). From a checkout you can run `make mcpb` (requires the [`@anthropic-ai/mcpb`](https://www.npmjs.com/package/@anthropic-ai/mcpb) CLI on your `PATH`).
 ## Examples
@@ -378,7 +407,7 @@ with GitCode(
 Use `httpx.AsyncClient(verify=...)` with `AsyncGitCode` for async code.
-The OpenAI tool (`GitCodeOpenAITool`) and MCP helpers accept the same `client=` / `async_client=` arguments (or a shared `GitCodeLLMTool` via `tool=` with those clients set). Build `GitCode` / `AsyncGitCode` with your custom `http_client` once and pass it through so LLM tool calls reuse the same TLS settings.
+The OpenAI tool (`GitCodeOpenAITool`), MCP helpers, and `create_openjiuwen_gitcode_api_tool` accept the same `client=` / `async_client=` arguments (OpenAI and MCP also accept a shared `GitCodeLLMTool` via `tool=`). Build `GitCode` / `AsyncGitCode` with your custom `http_client` once and pass it through so LLM tool calls reuse the same TLS settings.
 ## Project Status

{gitcode_api-1.2.8 → gitcode_api-1.2.10}/gitcode_api.egg-info/SOURCES.txt RENAMED Viewed

@@ -21,6 +21,7 @@ gitcode_api.egg-info/requires.txt
 gitcode_api.egg-info/top_level.txt
 gitcode_api/llm/__init__.py
 gitcode_api/llm/_tool.py
+gitcode_api/llm/jiuwen.py
 gitcode_api/llm/mcp.py
 gitcode_api/llm/openai.py
 gitcode_api/resources/__init__.py

{gitcode_api-1.2.8 → gitcode_api-1.2.10}/pyproject.toml RENAMED Viewed

@@ -1,10 +1,10 @@
 [project]
 name = "gitcode-api"
-version = "1.2.8"
-description = "Easy to use Python SDK for the GitCode REST API. Providing builtin CLI tool, and optional LLM integration (MCP and OpenAI tool) for agents. Community-maintained."
+version = "1.2.10"
+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",
-    "mcp", "agent", "fastmcp", "llm", "mcp client", "mcp server", "model context protocol",
+    "mcp", "agent", "fastmcp", "llm", "openjiuwen", "mcp client", "mcp server", "model context protocol",
 ]
 readme = "README.md"
 requires-python = ">=3.9,<4"

{gitcode_api-1.2.8 → gitcode_api-1.2.10}/tests/test_llm_tools.py RENAMED Viewed

@@ -1,3 +1,5 @@
+import importlib.util
+import json
 from typing import Any, Dict
 import httpx
@@ -7,6 +9,7 @@ from gitcode_api.llm import (
     GitCodeOpenAITool,
     create_mcp_gitcode_api_tool,
     create_mcp_server,
+    create_openjiuwen_gitcode_api_tool,
     register_mcp_gitcode_api_tool,
 )
 from gitcode_api.llm._tool import (
@@ -42,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
@@ -61,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:
@@ -127,18 +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()
-    templates = await mcp.list_resource_templates()
-    assert any(str(r.uri) == "gitcode-api://help" for r in static)
-    assert any("{op_type}" in str(t.uri_template) for t in templates)
-    read = await mcp.read_resource("gitcode-api://help/pulls")
-    payload = read.contents[0].content
-    assert "Resource: pulls" in payload
 def test_mcp_registers_with_existing_server() -> None:
     class DummyMCP:
         def __init__(self) -> None:
@@ -156,3 +147,53 @@ def test_mcp_registers_with_existing_server() -> None:
     assert registered.__name__ == "gitcode_api_tool"
     assert server.registered[0]["name"] == "gitcode_api_tool"
+@pytest.mark.skipif(importlib.util.find_spec("openjiuwen") is not None, reason="openjiuwen is installed")
+def test_create_openjiuwen_gitcode_api_tool_raises_when_openjiuwen_missing() -> None:
+    with pytest.raises(ImportError, match="openjiuwen|openJiuwen"):
+        create_openjiuwen_gitcode_api_tool(api_key="test-token")
+@pytest.mark.skipif(importlib.util.find_spec("openjiuwen") is None, reason="openjiuwen not installed")
+def test_create_openjiuwen_gitcode_api_tool_exposes_tool_card() -> None:
+    jiuwen_tool = create_openjiuwen_gitcode_api_tool(api_key="test-token")
+    assert jiuwen_tool.card.name == "gitcode_api_tool"
+    assert "op_type" in jiuwen_tool.card.input_params.get("properties", {})
+@pytest.mark.skipif(importlib.util.find_spec("openjiuwen") is None, reason="openjiuwen not installed")
+def test_create_openjiuwen_gitcode_api_tool_custom_name_and_description() -> None:
+    jiuwen_tool = create_openjiuwen_gitcode_api_tool(
+        api_key="test-token",
+        name="my_gitcode",
+        description="Custom GitCode tool copy.",
+    )
+    assert jiuwen_tool.card.name == "my_gitcode"
+    assert jiuwen_tool.card.description == "Custom GitCode tool copy."
+@pytest.mark.skipif(importlib.util.find_spec("openjiuwen") is None, reason="openjiuwen not installed")
+@pytest.mark.asyncio
+async def test_create_openjiuwen_gitcode_api_tool_invoke(async_client_factory: Any) -> None:
+    captured: Dict[str, Any] = {}
+    def handler(request: httpx.Request) -> httpx.Response:
+        captured["url"] = str(request.url)
+        return httpx.Response(200, json={"full_name": "SushiNinja/GitCode-API"})
+    client, http_client = async_client_factory(handler)
+    try:
+        jiuwen_tool = create_openjiuwen_gitcode_api_tool(async_client=client)
+        result = await jiuwen_tool.invoke(
+            {
+                "op_type": "repos",
+                "action": "get",
+                "params": {"owner": "SushiNinja", "repo": "GitCode-API"},
+            }
+        )
+    finally:
+        await http_client.aclose()
+    assert "/repos/SushiNinja/GitCode-API" in captured["url"]
+    assert result == {"full_name": "SushiNinja/GitCode-API"}