onegenie 0.1.0__tar.gz

onegenie-0.1.0/.gitignore

@@ -0,0 +1,57 @@
+coverage
+dist
+node_modules
+*.log
+.direnv
+.envrc.custom
+versions.json
+versions.html
+.DS_Store
+user-upload/
+.babel-error
+src/uid/global.css
+secrets/
+env
+.eslintcache
+*.sql
+!db/seeds/cmdb-data.sql
+newapp-bin
+.dbchecksum
+.skip-starting-bg-jobs
+.mixin-outsync
+
+.yarn/*
+!.yarn/cache
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/sdks
+!.yarn/versions
+
+*.blend1
+of.csv
+
+*.dxf
+uploads/
+minio-data/
+
+build/qdrant_data
+*.gz
+downloads/
+thei/
+.restart-express
+
+sqlite.db
+oasis.tar
+test/aisc-support/
+
+generated.jpg
+
+test/ntpo/*.csv
+__pycache__/
+*.db
+*.db-shm
+*.db-wal
+*.db-journal
+
+employees.sql.gz

onegenie-0.1.0/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: onegenie
+Version: 0.1.0
+Summary: The official Python SDK for AskGenie AI Platform
+Requires-Python: >=3.12
+Requires-Dist: json-repair>=0.57.0
+Requires-Dist: mcp>=1.26.0
+Requires-Dist: openai>=2.0.0
+Requires-Dist: orjson>=3.11.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: redis>=7.0.0
+Requires-Dist: requests>=2.31.0
+Description-Content-Type: text/markdown
+
+# OneGenie Official SDK

onegenie-0.1.0/README.md

@@ -0,0 +1 @@
+# OneGenie Official SDK

onegenie-0.1.0/onegenie/__init__.py

@@ -0,0 +1,10 @@
+from .agent import Agent, ModelConfig
+from .context import Context
+
+__all__ = [
+    "Agent",
+    "ModelConfig",
+    "Context",
+]
+
+__version__ = "0.1.0"

onegenie-0.1.0/onegenie/agent.py

@@ -0,0 +1,51 @@
+from typing import List, Callable, Optional, Dict, Any
+from pydantic import BaseModel
+from .context import Context
+
+
+class ModelConfig(BaseModel):
+    id: str
+    features: Optional[Dict[str, Any]] = None
+
+
+class Agent:
+    def __init__(
+        self,
+        id: str,
+        name: str,
+        desc: str,
+        models: List[ModelConfig],
+        extra_params: Any = None,
+        survey: Any = None,
+    ):
+        self.id = id
+        self.name = name
+        self.desc = desc
+        self.models = models
+        self.extra_params = extra_params
+        self.survey = survey
+        self._run_handler: Optional[Callable[[Context], Any]] = None
+
+    def on_run(self, func: Callable[[Context], Any]):
+        self._run_handler = func
+        return func
+
+    def serve(self):
+        if not self._run_handler:
+            raise ValueError("Missing @agent.on_run")
+
+        agent_card = {
+            "id": self.id,
+            "name": self.name,
+            "desc": self.desc,
+            "models": [m.model_dump(exclude_none=True) for m in self.models],
+        }
+
+        agent_card["extra_params"] = self.extra_params or {}
+
+        if self.survey is not None:
+            agent_card["extra_params"]["survey"] = self.survey
+
+        from .daemon import start_daemon
+
+        start_daemon(agent_card, self._run_handler)

onegenie-0.1.0/onegenie/context.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass
+from typing import List, Dict, Any, Callable
+
+
+class LLMTools:
+    def __init__(self, gen_stream: Callable, gen: Callable):
+        self.gen_stream = gen_stream
+        self.gen = gen
+
+
+class FSTools:
+    def __init__(self, upload_file: Callable):
+        self.upload_file = upload_file
+
+
+@dataclass
+class Context:
+    messages: List[Dict[str, Any]]
+    extra_params: Dict[str, Any]
+    llm: LLMTools
+    fs: FSTools
+    mcp: Any

onegenie-0.1.0/onegenie/daemon.py

@@ -0,0 +1,270 @@
+import os
+import uuid
+import asyncio
+import requests
+import redis.asyncio as redis
+import redis as sync_redis
+
+from .util import dumps, loads, gen, gen_stream
+from .mcp_agent import MCPAgent
+from .context import Context, LLMTools, FSTools
+
+
+def register_agent(card):
+    ASKGENIE_ENDPOINT = os.getenv("ASKGENIE_ENDPOINT")
+    if ASKGENIE_ENDPOINT is None:
+        raise Exception("Expected ASKGENIE_ENDPOINT but missing")
+
+    ASKGENIE_DEVELOPER_KEY = os.getenv("ASKGENIE_DEVELOPER_KEY")
+    if ASKGENIE_DEVELOPER_KEY is None:
+        raise Exception("Expected ASKGENIE_DEVELOPER_KEY but missing")
+
+    REGISTER_URL = f"{ASKGENIE_ENDPOINT}/agent/register"
+
+    print("Register agent to system...")
+    resp = requests.post(
+        REGISTER_URL,
+        json={"agent": card},
+        headers={"X-API-KEY": ASKGENIE_DEVELOPER_KEY},
+        timeout=10,
+    )
+
+    if resp.status_code != 200:
+        print(resp.text)
+    resp.raise_for_status()
+    return resp.json()
+
+
+# Configuration
+GROUP_NAME = "default"
+CONSUMER_NAME = "consumer-1"
+DGG_SSE_URL = "http://localhost:8081/sse"
+
+
+class TaskSession:
+    """管理單一任務生命週期與平台 API 工具的會話物件"""
+
+    def __init__(self, r, job_id, api_token, s3_ticket, response_channel):
+        self.r = r
+        self.job_id = job_id
+        self.api_token = api_token
+        self.s3_ticket = s3_ticket
+        self.response_channel = response_channel
+
+    # upload a file
+    async def upload_file(self, *, filename, srcpath=None, content=None, type="file"):
+        if type not in ("file", "streamlit_app"):
+            raise ValueError(
+                f"Upload Error: unsupported type '{type}'. Allowed types are 'file' and 'streamlit_app'."
+            )
+
+        if (srcpath is None and content is None) or (
+            srcpath is not None and content is not None
+        ):
+            raise ValueError(
+                "Upload Error: Must provide exactly one of 'srcpath' or 'content'"
+            )
+
+        _, file_ext = os.path.splitext(filename)
+        file_ext = file_ext.lower()
+
+        if not file_ext:
+            raise ValueError(
+                "Upload Error: extension is expected but missing in filename"
+            )
+
+        # filename security check
+        unsafe_chars = ["/", "\\", "..", "\0"]
+        if any(char in filename for char in unsafe_chars) or filename.strip() == "":
+            raise ValueError(f"Upload Error: illegal filename ('{filename}')")
+
+        # generate uuid for storage
+        uuid_filename = f"{uuid.uuid4()}{file_ext}"
+        url = self.s3_ticket["url"]
+        fields = self.s3_ticket["fields"].copy()
+        fields["key"] = fields["key"].replace("${filename}", uuid_filename)
+        s3_filepath = fields["key"]
+        print(f"Ready to upload: File [{filename}] -> S3 path [{s3_filepath}]")
+
+        # stream to s3
+        def _perform_upload():
+            if srcpath is not None:
+                with open(srcpath, "rb") as f:
+                    return requests.post(
+                        url, data=fields, files={"file": f}, allow_redirects=False
+                    )
+            else:
+                # Handle in-memory content (convert str to bytes if necessary)
+                file_data = (
+                    content.encode("utf-8") if isinstance(content, str) else content
+                )
+                # requests allows a tuple for files: (filename, data)
+                return requests.post(
+                    url,
+                    data=fields,
+                    files={"file": (uuid_filename, file_data)},
+                    allow_redirects=False,
+                )
+
+        response = await asyncio.to_thread(_perform_upload)
+        print(f"Upload {uuid_filename} Status code: {response.status_code}")
+
+        if response.status_code == 204:
+            payload = {
+                "jobId": self.job_id,
+                "status": "processing",
+                "filename": filename,  # for display and download
+                "s3_filepath": s3_filepath,  # for storage
+                "type": type,
+            }
+            msg = dumps(payload)
+
+            print(f"job_id: {self.job_id} | Ready to Publish: {payload}")
+            await self.r.publish(self.response_channel, msg)
+        else:
+            print(f"Upload Failed: {response.text}")
+
+    # streaming output
+    async def gen_stream(self, *, messages=[], model, tools=[]):
+        async for chunk in gen_stream(
+            messages=messages, model=model, api_token=self.api_token, tools=tools
+        ):
+            yield chunk
+
+    # blocking one time generation
+    async def gen(self, *, messages=[], model, tools=[]):
+        return await gen(
+            messages=messages, model=model, api_token=self.api_token, tools=tools
+        )
+
+
+async def process_task(r, task_data, handler_func, response_channel):
+    job_id = task_data.get("id")
+    agent = task_data.get("agent")
+    messages = task_data.get("messages")
+    api_token = task_data.get("token")
+    extra_params = task_data.get("extra_params")
+    s3_ticket = task_data.get("s3_ticket")
+
+    print(f"Processing job agent[{agent}] job_id[{job_id}]...")
+
+    session = TaskSession(r, job_id, api_token, s3_ticket, response_channel)
+    mcp_agent = MCPAgent(DGG_SSE_URL, api_token, session.gen_stream)
+
+    ctx = Context(
+        messages=messages,
+        extra_params=extra_params,
+        llm=LLMTools(gen_stream=session.gen_stream, gen=session.gen),
+        fs=FSTools(upload_file=session.upload_file),
+        mcp=mcp_agent,
+    )
+
+    try:
+        output = ""
+        async for chunk in handler_func(ctx):
+            msg = dumps({"jobId": job_id, "status": "processing", "chunk": chunk})
+            output += chunk
+            await r.publish(response_channel, msg)
+
+        await r.publish(
+            response_channel,
+            dumps({"jobId": job_id, "status": "done", "output": output}),
+        )
+
+    except Exception as e:
+        print(f"Error processing {job_id}: {e}")
+        err_msg = dumps({"status": "error", "error": str(e)})
+        await r.publish(response_channel, err_msg)
+
+
+async def start_heartbeat(r, hb_key):
+    while True:
+        try:
+            await r.set(hb_key, "alive", ex=45)
+            await asyncio.sleep(30)
+        except Exception as e:
+            print(f"Heartbeat failed: {e}")
+            await asyncio.sleep(30)
+
+
+async def main(agent_card, handler_func, ctx):
+    info = register_agent(agent_card)
+    print("Registration completed.", info)
+
+    ctx["redis_url"] = info["redisUrl"]
+    r = redis.from_url(info["redisUrl"], decode_responses=True)
+    print(f"Python Agent Daemon connected to {info['redisUrl']}")
+
+    worker_id = uuid.uuid4().hex
+    ctx["hb_key"] = info["heartbeatPattern"].replace(":*", f":{worker_id}")
+    print(f"heartbeat_key: {ctx['hb_key']}")
+
+    MAX_CONCURRENCY = 10
+    sem = asyncio.Semaphore(MAX_CONCURRENCY)
+
+    # We need to keep track of running tasks to cancel them on shutdown if needed
+    background_tasks = set()
+
+    heartbeat_task = asyncio.create_task(start_heartbeat(r, ctx["hb_key"]))
+
+    async def task_wrapper(mid, task_data):
+        try:
+            await process_task(r, task_data, handler_func, info["outputChannel"])
+            await r.xack(info["streamKey"], GROUP_NAME, mid)
+        except Exception as e:
+            print(f"Task processing error: {e}")
+        finally:
+            sem.release()
+
+    while True:
+        try:
+            await sem.acquire()
+
+            response = await r.xreadgroup(
+                GROUP_NAME,
+                CONSUMER_NAME,
+                streams={info["streamKey"]: ">"},
+                count=1,
+                block=0,
+            )
+            if response:
+                stream_name, messages = response[0]
+                message_id, data = messages[0]
+
+                task_payload = loads(data.get("payload"))
+
+                # Create background task and add to set
+                t = asyncio.create_task(task_wrapper(message_id, task_payload))
+                background_tasks.add(t)
+
+                # Remove task from set when done
+                t.add_done_callback(background_tasks.discard)
+            else:
+                # If no message, release the semaphore immediately so we can loop again
+                sem.release()
+
+        except Exception as e:
+            print(f"Critical error in loop: {e}")
+            heartbeat_task.cancel()
+            await heartbeat_task
+            if background_tasks:
+                await asyncio.wait(background_tasks)
+            await asyncio.sleep(1)  # Prevent tight loop on Redis connection fail
+
+
+def start_daemon(agent_card, handler_func):
+    ctx = {}
+    try:
+        asyncio.run(main(agent_card, handler_func, ctx))
+    except KeyboardInterrupt:
+        print("Daemon stopped.")
+    finally:
+        if "hb_key" in ctx:
+            print(f"Cleaning up heartbeat: {ctx['hb_key']}...")
+            try:
+                # Use standard 'redis' (not asyncio) to guarantee execution
+                r = sync_redis.from_url(ctx["redis_url"])
+                r.delete(ctx["hb_key"])
+                print("Cleanup successful.")
+            except Exception as e:
+                print(f"Cleanup failed: {e}")

onegenie-0.1.0/onegenie/mcp_agent.py

@@ -0,0 +1,235 @@
+from json_repair import repair_json
+
+from contextlib import AsyncExitStack
+from typing import Optional
+
+from mcp import ClientSession
+from mcp.client.sse import sse_client
+
+
+class MCPAgent:
+    def __init__(self, dgg_url: str, api_token: str, default_gen_stream=None):
+        self.dgg_url = dgg_url
+        self.api_token = api_token
+        self.exit_stack = AsyncExitStack()
+        self.dgg: Optional[ClientSession] = None
+        self.messages = []
+        self.default_gen_stream = default_gen_stream
+
+    async def __aenter__(self):
+        """進入 async with 區塊時自動觸發"""
+        await self.start()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """離開 async with 區塊時自動觸發（即使發生 Exception 也會執行）"""
+        # exc_type, exc_val, exc_tb 是用來捕捉區塊內發生錯誤時的資訊
+        # 在這裡我們只需要確保資源被正確關閉即可
+        await self.stop()
+
+    async def start(self):
+        """建立與 DGG 的連線，並傳入 User Context Headers"""
+        print("Connecting to DGG...")
+
+        # [關鍵] 我們把 User Context 放在 Header 傳給 DGG
+        # DGG 的 handle_sse 需要修改以讀取這些 Headers 來做 OPA Filtering
+        headers = {"X-JWT-TOKEN": self.api_token}
+
+        # 使用 AsyncExitStack 管理 Context Manager
+        sse_transport = await self.exit_stack.enter_async_context(
+            sse_client(self.dgg_url, headers=headers)
+        )
+        self.dgg = await self.exit_stack.enter_async_context(
+            ClientSession(sse_transport[0], sse_transport[1])
+        )
+
+        await self.dgg.initialize()
+        print("✅ Connected & Initialized!")
+
+    def _convert_mcp_to_openai_tools(self, mcp_tools):
+        """[關鍵] 將 MCP 工具格式轉換為 OpenAI/vLLM 格式"""
+        openai_tools = []
+        for tool in mcp_tools.tools:
+            openai_tools.append(
+                {
+                    "type": "function",
+                    "function": {
+                        "name": tool.name,
+                        "description": tool.description,
+                        "parameters": tool.inputSchema,  # MCP Schema 相容 JSON Schema
+                    },
+                }
+            )
+        return openai_tools
+
+    def _robust_parse_arguments(self, args_str: str) -> dict:
+        if not args_str:
+            return {}
+
+        args_str = args_str.strip()
+
+        # --- 第一道防線：手動補全結構 ---
+        # 如果不像是一個物件的開頭，我們強制幫它補上 '{'
+        if not args_str.startswith("{"):
+            # 你的案例會在這裡被修復
+            args_str = "{" + args_str
+
+        # 同理，如果沒結尾，補上 '}'
+        if not args_str.endswith("}"):
+            args_str = args_str + "}"
+
+        # --- 第二道防線：json_repair 修復語法 ---
+        # 這裡會處理單引號、trailing comma、未轉義字符等細節
+        try:
+            decoded = repair_json(args_str, return_objects=True)
+
+            # [重要] 確保回傳的一定是 dict
+            # 有時候 json_repair 修復失敗會回傳原始字串，這會導致後續報錯
+            if isinstance(decoded, dict):
+                return decoded
+            elif isinstance(decoded, list):
+                # 極少見情況，但以防萬一
+                return {"items": decoded}
+            else:
+                # 如果回傳的是字串，代表修復失敗或內容根本不是 JSON
+                print(f"⚠️ json_repair returned non-dict: {type(decoded)}")
+                # 嘗試最後一次暴力解析 (針對 key: value 這種格式)
+                return self._fallback_parse(args_str)
+
+        except Exception as e:
+            print(f"❌ JSON Parsing Failed: {e}")
+            return {}
+
+    async def chat(self, history: list):
+        if not self.dgg:
+            raise RuntimeError("Agent not started")
+
+        self.messages = history
+
+        # 1. 向 DGG 拿工具 (DGG 會根據 Header 過濾工具)
+        mcp_tools = await self.dgg.list_tools()
+        openai_tools = self._convert_mcp_to_openai_tools(mcp_tools)
+
+        # --- ReAct Loop ---
+        while True:
+            current_tool_calls = {}  # 用來暫存工具呼叫的片段
+            is_collecting_tool = False
+            full_response_content = ""
+
+            # A. 呼叫 LLM
+            async for delta in self.default_gen_stream(
+                messages=self.messages,
+                model="llm",
+                tools=openai_tools if openai_tools else None,
+            ):
+                # delta.reasoning_content
+                # print(delta)
+                # --- 情況 A: LLM 決定呼叫工具 (攔截模式) ---
+                if delta.tool_calls:
+                    is_collecting_tool = True
+                    for tc in delta.tool_calls:
+                        idx = tc.index
+                        if idx not in current_tool_calls:
+                            current_tool_calls[idx] = {
+                                "id": tc.id,
+                                "name": tc.function.name,
+                                "arguments": "",
+                            }
+                        # 拼湊 JSON 片段
+                        if tc.function.arguments:
+                            current_tool_calls[idx]["arguments"] += (
+                                tc.function.arguments
+                            )
+
+                    # 選用：你可以 yield 一個 "正在分析工具..." 的狀態給 UI
+                    # yield "[STATUS: Analyzing...]"
+
+                # --- 情況 B: LLM 正在說話 (直通模式) ---
+                elif delta.content:
+                    # 如果我們確認不是在組裝工具，就直接串流給用戶
+                    if not is_collecting_tool:
+                        full_response_content += delta.content
+                        yield delta.content
+
+            if is_collecting_tool:
+                # 這裡不需要 yield content，因為上面攔截了
+
+                # 建構完整的 Assistant Message (為了塞回歷史紀錄)
+                tool_calls_data = []
+                for idx, tc in current_tool_calls.items():
+                    tool_calls_data.append(
+                        {
+                            "id": tc["id"],
+                            "type": "function",
+                            "function": {
+                                "name": tc["name"],
+                                "arguments": tc["arguments"],
+                            },
+                        }
+                    )
+
+                # 把「意圖」存入歷史 (即使沒顯示給用戶，LLM 需要知道它呼叫了工具)
+                self.messages.append(
+                    {
+                        "role": "assistant",
+                        "content": None,
+                        "tool_calls": tool_calls_data,
+                    }
+                )
+
+                # 通知 UI 我們正在執行 (UX 優化)
+                for tc in tool_calls_data:
+                    func_name = tc["function"]["name"]
+                    # yield f"\n\n> ⚙️ *Calling {func_name}...*\n\n"
+
+                    # ... (執行 Tool 的邏輯與之前相同) ...
+                    # result = await self.dgg.call_tool(...)
+                    # self.messages.append(tool_result_message)
+                    func_args_str = tc["function"]["arguments"]
+                    call_id = tc["id"]
+
+                    print(f"⚡ Executing: {func_name} with {func_args_str}")
+
+                    try:
+                        # 解析參數 JSON
+                        func_args = self._robust_parse_arguments(func_args_str)
+
+                        # 呼叫 DGG (MCP Protocol)
+                        result = await self.dgg.call_tool(func_name, func_args)
+
+                        # 提取文字結果
+                        tool_output = ""
+                        for content in result.content:
+                            if content.type == "text":
+                                tool_output += content.text
+
+                    except Exception as e:
+                        tool_output = f"Error: {str(e)}"
+
+                    print(f"   -> Result: {tool_output[:50]}...")
+
+                    # E. 將工具執行結果回傳給 LLM (Role: tool)
+                    # OpenAI 格式要求必須帶上 tool_call_id
+                    self.messages.append(
+                        {
+                            "role": "tool",
+                            "tool_call_id": call_id,
+                            "name": func_name,
+                            "content": tool_output,
+                        }
+                    )
+
+                # [關鍵] 執行完工具後，continue 回到 while 開頭
+                # 下一輪 LLM 會看到 Tool Result，然後開始解釋 (這時就會進入情況 B 串流文字)
+                continue
+
+            # 2. 如果沒有工具呼叫 -> 結束對話
+            else:
+                # 把完整的文字回應存入歷史
+                self.messages.append(
+                    {"role": "assistant", "content": full_response_content}
+                )
+                return  # 結束 Loop
+
+    async def stop(self):
+        await self.exit_stack.aclose()

onegenie-0.1.0/onegenie/util.py

@@ -0,0 +1,120 @@
+import re
+import os
+import json
+import orjson
+from openai import AsyncOpenAI, APIError
+
+base_url = os.environ["ASKGENIE_ENDPOINT"].replace("/api/v1", "/mpg/v1")
+
+chunksize = 30000
+
+
+def dumps(obj) -> str:
+    return orjson.dumps(obj).decode("utf-8")
+
+
+def loads(json_str: str | bytes):
+    return orjson.loads(json_str)
+
+
+def read_file(path, default=None):
+    print(f"Reading File content from {path}...")
+    if os.path.exists(path):
+        with open(path, "r") as file:
+            return file.read()
+    else:
+        if default is None:
+            raise Exception(f"File do not exists: {path}")
+        else:
+            return default
+
+
+async def gen(messages, model, api_token, tools=None):
+    client = AsyncOpenAI(base_url=base_url, api_key=api_token)
+
+    params = {
+        "model": model,
+        "messages": messages,
+    }
+
+    if tools:
+        params["tools"] = tools
+        params["tool_choice"] = "auto"
+
+    try:
+        response = await client.chat.completions.create(**params)
+        return response.choices[0].message
+    except Exception as e:
+        print(f"LLM Error: {e}")
+        raise e
+
+
+# def genWithlogprobs(prompt, top_logprobs=10):
+#     response = llm.chat.completions.create(
+#         model=model_id,
+#         messages=[{"role": "user", "content": prompt}],
+#         logprobs=True,
+#         top_logprobs=top_logprobs,
+#     )
+#     return response
+#
+#
+# async def agen(prompt):
+#     response = await llm_stream.chat.completions.create(
+#         model=model_id, messages=[{"role": "user", "content": prompt}]
+#     )
+#     return response.choices[0].message.content
+
+
+# history = [
+#     {"role": "system", "content": "You are a helpful assistant."},
+#     {"role": "user", "content": "What's the capital of France?"},
+#     {"role": "assistant", "content": "Paris."},
+# ]
+async def gen_stream(messages, model, api_token, tools=None):
+    # messages = history + [{"role": "user", "content": prompt}]
+    mpg = AsyncOpenAI(base_url=base_url, api_key=api_token)
+
+    params = {
+        "model": model,
+        "messages": messages,
+        "stream": True,
+    }
+
+    if tools:
+        params["tools"] = tools
+        params["tool_choice"] = "auto"
+
+    try:
+        stream = await mpg.chat.completions.create(**params)
+        async for chunk in stream:
+            # Extract the content delta
+            if chunk.choices:
+                delta = chunk.choices[0].delta
+                if delta:
+                    yield delta
+
+            elif hasattr(chunk, "usage") and chunk.usage:
+                continue
+
+    except APIError as e:
+        yield f"Failed: {e.message}"
+
+    except Exception as e:
+        yield f"Failed: {str(e)}"
+
+
+def trim_and_load_json(input):
+    start = input.find("{")
+    end = input.rfind("}") + 1
+    if end == 0 and start != -1:
+        input = input + "}"
+        end = len(input)
+    jsonStr = input[start:end] if start != -1 and end != 0 else ""
+    jsonStr = re.sub(r",\s*([\]}])", r"\1", jsonStr)
+    try:
+        return json.loads(jsonStr)
+    except json.JSONDecodeError:
+        return []
+    except Exception:
+        return []

onegenie-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "onegenie"
+version = "0.1.0"
+description = "The official Python SDK for AskGenie AI Platform"
+
+readme = "README.md"
+
+requires-python = ">=3.12"
+dependencies = [
+    "pydantic>=2.0.0",
+    "redis>=7.0.0",
+    "requests>=2.31.0",
+    "orjson>=3.11.0",
+    "mcp>=1.26.0",
+    "openai>=2.0.0",
+    "json-repair>=0.57.0",
+]
+
+[dependency-groups]
+dev = [
+    "honcho>=2.0.0",
+    "watchdog>=6.0.0",
+    "pandas==2.3.3",
+    "boto3>=1.42.82",
+    "arize-phoenix-client==1.24.0",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["onegenie"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "/onegenie",
+]