response = await new_client.aio_client.images.upload_ask("Describe this image:", "/path/to/example.jpg")
print(response)

response_content = await new.aio_client.images.create("make a generate cat blue")
await response_content.to_save()

response = await new.aio_client.images.create_upload_ask("Describe this image:", "/path/to/example.jpg")
await response.to_result()

response = await new.aio_client.chat.ask("What's the capital of Japan?")
print(await response.to_result())

from Ryzenth import RyzenthTools

gemini_magic = RyzenthTools()

response = await gemini_magic.aio_client.images.create_gemini_and_captions(
    "Bikin gambar 3D babi pake sayap jet + kacamata hitam"
    "lagi terbang di atas kota cyberpunk yang ujan neon"
)

img, caption = await response.to_buffer_and_list()

await message.reply_photo(
    photo=img,
    caption=caption
)

Ga pake lama proses cepet ga nunggu loading kayak nunggu gorengan. ⏳

No ribet token ga perlu setel config bertele tele.

Dijamin stabil backend pake TypeScript jadi jarang error.

await new.aio_client.images.create()
await new.aio_client.images.create_gemini_and_captions()
await new.aio_client.images.create_gemini_to_edit("add background Lamborghini", "/path/to/example.jpg") # use response.to_buffer_and_list()
await new.aio_client.images.create_upload_to_ask()
await new.aio_client.images.create_multiple()
await new.aio_client.chat.ask()
await new.aio_client.chat.ask_ultimate()

from Ryzenth import RyzenthApiClient

class CustomName:
    def __init__(self):
        self.client = RyzenthApiClient()

    async def sapa(self):
        pass

qwen_response = await aio.client.images.create_qwen_flash()

url = await qwen_response.create_task_and_wait(return_url=True)

from Ryzenth import RyzenthTools

_ = RyzenthTools("your-api-key-from-qwen")

response = await _.aio_client.qwen_images.create_qwen_flash("make a generate cat blue")

url = await response.create_task_and_wait(
    max_retries=120,
    poll_interval=1.0,
    return_url=True
)
print(url)

from Ryzenth import RyzenthTools

rt = RyzenthTools("your-api-key-from-qwen")

# ---------------------------
# 1. Generate Image
# ---------------------------
response = await rt.aio.qwen_images.create("make a generate cat blue")
output = await response.create_task_and_wait(max_retries=120, poll_interval=1.0)

print("Image URL:", output.results[0].url)

# ---------------------------
# 2. Generate Video
# ---------------------------
response_two = await rt.aio.qwen_videos.create("make a generate cat blue run")
output_two = await response_two.create_task_and_wait(max_retries=120, poll_interval=1.0)

print("Video URL:", output_two.video_url)

response = await rt.aio.qwen_images.create("make a generate meme random")
output = await response.run()

response_chats = await rt.aio.qwen_chat.ask(
    "Hey, what’s your name?",
    stream=False,
    include_usage=False,
    enable_thinking=True
)
obj = await response_chats.to_obj()

from Ryzenth import RyzenthTools

rt = RyzenthTools("api-key-from-qwen")

response = await rt.aio.qwen_images.to_edit(
    prompt="Convert face to anime",
    base_image_url="",
    function_call="stylization_all"
)
f = await response.run()
print(f)

from Ryzenth import RyzenthTools

openai_st = RyzenthTools("sk-proj-*")
qwen_st = RyzenthTools("sk-*")
default_st = RyzenthTools()

await openai_st.aio.openai_responses.create()
await qwen_st.aio.qwen_chat.ask()
await default_st.aio.chat.ask()

from Ryzenth import RyzenthTools

rt = RyzenthTools("api-key-from-qwen")

response = await rt.aio.qwen_images.create("make a generate cat blue and background car Lamborghini gold")

output = await response.run()

img = await response.to_buffer_request(output.results[0].url)

await message.reply_photo(img)

from Ryzenth import RyzenthTools

rt = RyzenthTools("sk-proj-xxxx")

response = await rt.aio.openai_images.create("....")

dict_to_obj = await response.to_obj()

img = await response.to_buffer_request(
    dict_to_obj.data[0].b64_json,
    return_image_base64=True,
    disabled_http=True
)

from Ryzenth import RyzenthTools

rt = RyzenthTools("api-key-from-cohere")

prompt = "what otak popcorn?"

demo_history = []

demo_history.append({"role": "USER", "message": prompt})

response = await rt.aio.cohere_chat.ask(
    prompt,
    chat_history=demo_history,
    connectors=[{"id": "web-search"}]
)

chat = await response.to_obj()
demo_history.append({"role": "CHATBOT", "message": chat.text})

print(chat.text)

from Ryzenth import RyzenthTools

rt = RyzenthTools("api-key-from-openai")

prompt = "what programmer?"

response = await rt.aio.openai_responses.create(prompt)

chat = await response.to_obj()
print(chat.data[0].content[0].text)

response = await rt.aio.openai_responses.create(
    prompt=[
        {"role": "developer", "content": "Talk like a pirate."},
        {"role": "user", "content": "Are semicolons optional in JavaScript?"},
    ],

await response.to_dict()