pygpt-net 2.6.19.post1__py3-none-any.whl → 2.6.21__py3-none-any.whl

pygpt_net/core/experts/experts.py

@@ -6,11 +6,11 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.21 07:00:00                  #
+# Updated Date: 2025.08.23 15:00:00                  #
 # ================================================== #
 
 import json
-from typing import Dict, List
+from typing import Dict, List, Optional
 
 from PySide6.QtCore import Slot
 
@@ -114,16 +114,17 @@ class Experts:
         :return: experts dict
         """
         experts = {}
-        presets = self.window.core.presets.get_by_mode(MODE_EXPERT)
+        core = self.window.core
+        presets = core.presets.get_by_mode(MODE_EXPERT)
 
         # mode: agent
         if self.agent_enabled():
-            agents = self.window.core.presets.get_by_mode(MODE_AGENT)
-            agent = self.window.core.config.get('preset')
+            agents = core.presets.get_by_mode(MODE_AGENT)
+            agent = core.config.get('preset')
             if agent is not None:
                 if agent in agents:
                     for uuid in agents[agent].experts:
-                        expert = self.window.core.presets.get_by_uuid(uuid)
+                        expert = core.presets.get_by_uuid(uuid)
                         if expert is not None:
                             id = expert.filename
                             experts[id] = expert
@@ -137,12 +138,12 @@ class Experts:
                 experts[k] = presets[k]
         return experts
 
-    def get_expert_name_by_id(self, id: str) -> str:
+    def get_expert_name_by_id(self, id: str) -> Optional[str]:
         """
         Get expert name by id
 
         :param id: expert id
-        :return: expert name
+        :return: expert name or None if not found
         """
         experts = self.get_experts()
         if id in experts:
@@ -156,10 +157,11 @@ class Experts:
         :return: number of experts
         """
         i = 0
-        agents = self.window.core.presets.get_by_mode(MODE_AGENT)
+        core = self.window.core
+        agents = core.presets.get_by_mode(MODE_AGENT)
         if uuid in agents:
             for expert_uuid in agents[uuid].experts:
-                expert = self.window.core.presets.get_by_uuid(expert_uuid)
+                expert = core.presets.get_by_uuid(expert_uuid)
                 if expert is not None:
                     i += 1
         return i
@@ -189,15 +191,16 @@ class Experts:
         :param ctx: context item
         :return: dict with calls
         """
+        core = self.window.core
         ids = self.get_experts().keys()
         if not ids:  # abort if no experts
             return {}
-        cmds = self.window.core.command.extract_cmds(ctx.output)
+        cmds = core.command.extract_cmds(ctx.output)
         if len(cmds) > 0:
             ctx.cmds = cmds  # append commands to ctx
         else:  # abort if no cmds
             return {}
-        commands = self.window.core.command.from_commands(cmds)  # pack to execution list
+        commands = core.command.from_commands(cmds)  # pack to execution list
         is_cmd = False
         my_commands = []
         calls = {}
@@ -220,7 +223,7 @@ class Experts:
                     query = item["params"]["query"]
                     calls[id] = query
             except Exception as e:
-                self.window.core.debug.log(e)
+                core.debug.log(e)
                 return {}
         return calls
 
@@ -272,9 +275,6 @@ class Experts:
         reply_ctx.output_name = ""
         reply_ctx.sub_call = True  # this flag is not copied in to_dict
 
-        internal = False
-        if self.agent_enabled():  # hide in agent mode
-            internal = True
         if ctx.output.strip() != "":
             response = reply_ctx.output
         else:
@@ -290,16 +290,15 @@ class Experts:
         if ctx.sub_reply:
             reply_ctx.extra["sub_reply"] = True  # mark as sub-reply
             context.prompt = json.dumps(result, ensure_ascii=False, indent=2)  # to master
-        extra = {
-            "force": True,
-            "reply": True,
-            "internal": internal,
-        }
-        event = KernelEvent(KernelEvent.INPUT_SYSTEM, {
+
+        self.window.dispatch(KernelEvent(KernelEvent.INPUT_SYSTEM, {
             'context': context,
-            'extra': extra,
-        })
-        self.window.dispatch(event)
+            'extra': {
+                "force": True,
+                "reply": True,
+                "internal": self.agent_enabled(),
+            },
+        }))
 
     def call(
             self,
@@ -317,26 +316,27 @@ class Experts:
         if self.stopped():
             return
 
-        self.worker = ExpertWorker(
+        worker = ExpertWorker(
             window=self.window,
             master_ctx=master_ctx,
             expert_id=expert_id,
-            query=query
+            query=query,
         )
-        self.worker.signals.response.connect(self.handle_response)  # connect to finished signal
-        self.worker.signals.finished.connect(self.handle_finished)  # connect to finished signal
-        self.worker.signals.error.connect(self.handle_error)  # connect to error signal
-        self.worker.signals.event.connect(self.handle_event)  # connect to event signal
-        self.worker.signals.output.connect(self.handle_output)  # connect to output signal
-        self.worker.signals.lock_input.connect(self.handle_input_locked)  # connect to lock input signal
-        self.worker.signals.cmd.connect(self.handle_cmd)  # connect to cmd signal
-
-        # start worker in thread pool
+        worker.signals.response.connect(self.handle_response)  # connect to finished signal
+        worker.signals.finished.connect(self.handle_finished)  # connect to finished signal
+        worker.signals.error.connect(self.handle_error)  # connect to error signal
+        worker.signals.event.connect(self.handle_event)  # connect to event signal
+        worker.signals.output.connect(self.handle_output)  # connect to output signal
+        worker.signals.lock_input.connect(self.handle_input_locked)  # connect to lock input signal
+        worker.signals.cmd.connect(self.handle_cmd)  # connect to cmd signal
+
+        # start worker in threadpool
+        self.worker = worker
         self.last_expert_id = expert_id  # store last expert id
         self.master_ctx = master_ctx
-        expert_name = self.get_expert_name_by_id(expert_id)
+        name = self.get_expert_name_by_id(expert_id)
         event = KernelEvent(KernelEvent.STATE_BUSY, {
-            "msg": f"{trans('expert.wait.status')} ({expert_name})",
+            "msg": f"{trans('expert.wait.status')} ({name})",
         })
         self.window.dispatch(event)  # dispatch busy event
         self.window.threadpool.start(self.worker)
@@ -355,7 +355,7 @@ class Experts:
         self.window.controller.chat.output.handle(
             ctx=ctx,
             mode=mode,
-            stream_mode=False,
+            stream=False,
         )
 
     @Slot(CtxItem, CtxItem, str, str, str)
@@ -379,31 +379,33 @@ class Experts:
         if self.stopped():
             return
 
+        core = self.window.core
+        update_status = self.window.update_status
+
         # extract native tool calls if provided
         if ctx.tool_calls:
             # if not internal commands in a text body then append tool calls as commands (prevent double commands)
-            if not self.window.core.command.has_cmds(ctx.output):
-                self.window.core.command.append_tool_calls(ctx)  # append tool calls as commands
+            if not core.command.has_cmds(ctx.output):
+                core.command.append_tool_calls(ctx)  # append tool calls as commands
                 if not isinstance(ctx.extra, dict):
                     ctx.extra = {}
                 ctx.extra["tool_calls"] = ctx.tool_calls
 
         # if 'get_context' tool is used then force call, and append idx
         self.extract_tool_calls(ctx)  # extract tool calls from ctx
-
         self.window.controller.chat.command.handle(ctx, internal=True)  # handle cmds sync
-        if ctx.reply:
-            self.window.update_status("")  # clear status
 
+        if ctx.reply:
+            update_status("")  # clear status
             # prepare data to send as reply
             tool_data = json.dumps(ctx.results)
             # if "tool_output" in ctx.extra and ctx.extra["tool_output"]:
                # tool_data = str(ctx.extra["tool_output"])
 
-            self.window.core.ctx.update_item(ctx)  # update context in db
-            self.window.update_status('...')
+            core.ctx.update_item(ctx)  # update context in db
+            update_status('...')
             ctx.output = f"<tool>{ctx.cmds}</tool>"
-            self.window.core.ctx.update_item(ctx)  # update ctx in DB
+            core.ctx.update_item(ctx)  # update ctx in DB
             self.handle_finished()
             self.call(
                 master_ctx=self.master_ctx,
@@ -461,34 +463,29 @@ class Experts:
 
         :param error: error message
         """
+        dispatch = self.window.dispatch
+
         if self.stopped():
-            event = KernelEvent(KernelEvent.STATE_IDLE, {})
-            self.window.dispatch(event)  # dispatch idle event
+            dispatch(KernelEvent(KernelEvent.STATE_IDLE, {}))  # dispatch idle event
             return
 
         # handle error from worker
         context = BridgeContext()
         context.prompt = f"{trans('expert.wait.failed')}: {error}"
-        extra = {
-            "force": True,
-            "reply": False,
-            "internal": False,
-        }
-        # reply to master
-        event = KernelEvent(KernelEvent.INPUT_SYSTEM, {
+        dispatch(KernelEvent(KernelEvent.INPUT_SYSTEM, {
             'context': context,
-            'extra': extra,
-        })
-        self.window.dispatch(event)
-        event = KernelEvent(KernelEvent.STATE_IDLE, {})
-        self.window.dispatch(event)  # dispatch idle event
+            'extra': {
+                "force": True,
+                "reply": False,
+                "internal": False,
+            },
+        }))  # reply to master
+        dispatch(KernelEvent(KernelEvent.STATE_IDLE, {}))  # dispatch idle event
 
     @Slot()
     def handle_finished(self):
         """Handle worker finished signal"""
-        event = KernelEvent(KernelEvent.STATE_IDLE, {})
-        self.window.dispatch(event)  # dispatch idle event
-
+        self.window.dispatch(KernelEvent(KernelEvent.STATE_IDLE, {}))  # dispatch idle event
 
     @Slot(CtxItem, str)
     def handle_response(self, ctx: CtxItem, expert_id: str):
@@ -498,9 +495,10 @@ class Experts:
         :param ctx: CtxItem
         :param expert_id: expert id
         """
+        dispatch = self.window.dispatch
+
         if self.stopped():
-            event = KernelEvent(KernelEvent.STATE_IDLE, {})
-            self.window.dispatch(event)  # dispatch idle event
+            dispatch(KernelEvent(KernelEvent.STATE_IDLE, {}))  # dispatch idle event
             return
 
         # handle reply from worker
@@ -510,20 +508,17 @@ class Experts:
             "expert_id": expert_id,
             "result": str(ctx.output),
         }
+        # TODO: clear ctx.output here?
         context.prompt = json.dumps(result, ensure_ascii=False, indent=2)  # prepare prompt for reply
-        extra = {
-            "force": True,
-            "reply": True,
-            "internal": False,
-        }
-        # reply to master
-        event = KernelEvent(KernelEvent.INPUT_SYSTEM, {
+        dispatch(KernelEvent(KernelEvent.INPUT_SYSTEM, {
             'context': context,
-            'extra': extra,
-        })
-        self.window.dispatch(event)
-        event = KernelEvent(KernelEvent.STATE_IDLE, {})
-        self.window.dispatch(event)  # dispatch idle event
+            'extra': {
+                "force": True,
+                "reply": True,
+                "internal": False,
+            },
+        }))  # reply to master
+        dispatch(KernelEvent(KernelEvent.STATE_IDLE, {}))  # dispatch idle event
 
     def get_functions(self) -> List[Dict[str, str]]:
         """
@@ -531,7 +526,7 @@ class Experts:
 
         :return: call the expert commands
         """
-        cmds = [
+        return [
             {
                 "cmd": TOOL_EXPERT_CALL_NAME,
                 "instruction": TOOL_EXPERT_CALL_DESCRIPTION,
@@ -551,7 +546,6 @@ class Experts:
                 ]
             }
         ]
-        return cmds
 
     def get_retriever_tool(self) -> Dict[str, str]:
         """
@@ -580,10 +574,10 @@ class Experts:
         :return: True if expert calls found
         """
         if not ctx.sub_reply and not ctx.reply:
-            mentions = self.window.core.experts.extract_calls(ctx)
+            mentions = self.extract_calls(ctx)
             if mentions:
                 for expert_id in mentions:
-                    if not self.window.core.experts.exists(expert_id):
+                    if not self.exists(expert_id):
                         continue
                     return True
         return False

pygpt_net/core/experts/worker.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.21 07:00:00                  #
+# Updated Date: 2025.08.23 15:00:00                  #
 # ================================================== #
 
 from typing import List, Optional
@@ -303,16 +303,6 @@ class ExpertWorker(QRunnable):
             self.signals.finished.emit()
             self.cleanup()
 
-    def cleanup(self):
-        """Cleanup resources after worker execution."""
-        sig = self.signals
-        self.signals = None
-        if sig is not None:
-            try:
-                sig.deleteLater()
-            except RuntimeError:
-                pass
-
     def call_agent(
             self,
             context: BridgeContext,
@@ -359,4 +349,14 @@ class ExpertWorker(QRunnable):
         if response_ctx:
             return str(response_ctx.output)
         else:
-            return "No response from expert."
+            return "No response from expert."
+
+    def cleanup(self):
+        """Cleanup resources after worker execution."""
+        sig = self.signals
+        self.signals = None
+        if sig is not None:
+            try:
+                sig.deleteLater()
+            except RuntimeError:
+                pass

pygpt_net/core/models/models.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.15 23:00:00                  #
+# Updated Date: 2025.08.24 03:00:00                  #
 # ================================================== #
 
 import copy
@@ -498,6 +498,10 @@ class Models:
                 args["api_key"] = cfg.get('api_key_hugging_face', "")
                 args["base_url"] = cfg.get('api_endpoint_hugging_face', "")
                 self.window.core.debug.info("[api] Using client: HuggingFace Router API")
+            elif model.provider == "ollama":
+                args["api_key"] = "ollama"
+                args["base_url"] = self.window.core.models.ollama.get_base_url() + "/v1"
+                self.window.core.debug.info("[api] Using client: Ollama")
             else:
                 self.window.core.debug.info("[api] Using client: OpenAI (default)")
 

pygpt_net/core/models/ollama.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.07.09 21:00:00                  #
+# Updated Date: 2025.08.24 03:00:00                  #
 # ================================================== #
 
 import os
@@ -22,16 +22,25 @@ class Ollama:
         self.window = window
         self.available_models = []
 
-    def get_status(self) -> dict:
+    def get_base_url(self) -> str:
         """
-        Check Ollama status
+        Get Ollama API base URL
 
-        :return: dict
+        :return: Ollama API base URL
         """
         api_base = "http://localhost:11434"
         if 'OLLAMA_API_BASE' in os.environ:
             api_base = os.environ['OLLAMA_API_BASE']
-        self.window.core.idx.log("Using Ollama base URL: {}".format(api_base))
+        return api_base
+
+    def get_status(self) -> dict:
+        """
+        Check Ollama status
+
+        :return: dict
+        """
+        api_base = self.get_base_url()
+        self.window.core.idx.log(f"Using Ollama base URL: {api_base}")
 
         url = api_base + "/api/tags"
         try:

pygpt_net/core/render/web/helpers.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.11 00:00:00                  #
+# Updated Date: 2025.08.24 02:00:00                  #
 # ================================================== #
 
 import re
@@ -136,7 +136,7 @@ class Helpers:
         :return: formatted text
         """
         s = text
-        if self.window.core.config.get("llama.idx.chat.agent.render.all", False):
+        if self.window.core.config.get("agent.output.render.all", False):
             if "__agent_begin__" in s or "__agent_end__" in s:
                 s = s.replace("__agent_begin__", '<div class="msg-agent">').replace("__agent_end__", "</div>")
         return s.strip()

pygpt_net/core/render/web/renderer.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.19 07:00:00                  #
+# Updated Date: 2025.08.24 02:00:00                  #
 # ================================================== #
 
 import json
@@ -594,10 +594,10 @@ class Renderer(BaseRenderer):
         """
         output = ctx.output
         if isinstance(ctx.extra, dict) and ctx.extra.get("output"):
-            if self.window.core.config.get("llama.idx.chat.agent.render.all", False):
-                output = f"__agent_begin__{ctx.output}__agent_end__{ctx.extra['output']}"
+            if self.window.core.config.get("agent.output.render.all", False):
+                output = ctx.output  # full agent output
             else:
-                output = ctx.extra["output"]
+                output = ctx.extra["output"] # final output only
         else:
             if not output:
                 return

pygpt_net/core/types/__init__.py

@@ -6,10 +6,11 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.07.13 01:00:00                  #
+# Updated Date: 2025.08.23 21:00:00                  #
 # ================================================== #
 
 from .agent import *
+from .base import *
 from .mode import *
 from .model import *
 from .openai import *

pygpt_net/core/types/agent.py

@@ -6,14 +6,14 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.07.30 00:00:00                  #
+# Updated Date: 2025.08.23 21:00:00                  #
 # ================================================== #
 
-AGENT_MODE_STEP = "agent.mode.step"  # LlamaIndex
-AGENT_MODE_PLAN = "agent.mode.plan"  # LlamaIndex
 AGENT_MODE_ASSISTANT = "agent.mode.assistant"  # LlamaIndex
-AGENT_MODE_WORKFLOW = "agent.mode.workflow"  # LlamaIndex
 AGENT_MODE_OPENAI = "agent.mode.openai"  # openai-agent
+AGENT_MODE_PLAN = "agent.mode.plan"  # LlamaIndex
+AGENT_MODE_STEP = "agent.mode.step"  # LlamaIndex
+AGENT_MODE_WORKFLOW = "agent.mode.workflow"  # LlamaIndex
 
 AGENT_TYPE_LLAMA = "agent.type.llama"  # LlamaIndex
 AGENT_TYPE_OPENAI = "agent.type.openai"  # OpenAI Agent

pygpt_net/core/types/base.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# ================================================== #
+# This file is a part of PYGPT package               #
+# Website: https://pygpt.net                         #
+# GitHub:  https://github.com/szczyglis-dev/py-gpt   #
+# MIT License                                        #
+# Created By  : Marcin Szczygliński                  #
+# Updated Date: 2025.08.23 21:00:00                  #
+# ================================================== #
+
+TYPE_BOOL = "bool"
+TYPE_DICT = "dict"
+TYPE_ENUM = "enum"
+TYPE_FLOAT = "float"
+TYPE_INT = "int"
+TYPE_LIST = "list"
+TYPE_STR = "str"
+TYPE_TEXT = "text"

pygpt_net/core/types/console.py

@@ -6,16 +6,16 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.07.21 15:00:00                  #
+# Updated Date: 2025.08.23 21:00:00                  #
 # ================================================== #
 
 class Color:
+    BOLD = '\033[1m'
+    ENDC = '\033[0m'
+    FAIL = '\033[91m'
     HEADER = '\033[95m'
     OKBLUE = '\033[94m'
     OKCYAN = '\033[96m'
     OKGREEN = '\033[92m'
-    WARNING = '\033[93m'
-    FAIL = '\033[91m'
-    ENDC = '\033[0m'
-    BOLD = '\033[1m'
-    UNDERLINE = '\033[4m'
+    UNDERLINE = '\033[4m'
+    WARNING = '\033[93m'

pygpt_net/core/types/mode.py

@@ -6,20 +6,20 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.07.30 00:00:00                  #
+# Updated Date: 2025.08.23 21:00:00                  #
 # ================================================== #
 
+MODE_AGENT = "agent"
+MODE_AGENT_LLAMA = "agent_llama"
+MODE_AGENT_OPENAI = "agent_openai"
+MODE_ASSISTANT = "assistant"
 MODE_AUDIO = "audio"
 MODE_CHAT = "chat"
 MODE_COMPLETION = "completion"
+MODE_COMPUTER = "computer"
+MODE_EXPERT = "expert"
 MODE_IMAGE = "img"
-MODE_VISION = "vision"
-MODE_ASSISTANT = "assistant"
 MODE_LANGCHAIN = "langchain"
 MODE_LLAMA_INDEX = "llama_index"
-MODE_AGENT = "agent"
-MODE_AGENT_LLAMA = "agent_llama"
-MODE_AGENT_OPENAI = "agent_openai"
-MODE_EXPERT = "expert"
 MODE_RESEARCH = "research"
-MODE_COMPUTER = "computer"
+MODE_VISION = "vision"

pygpt_net/core/types/multimodal.py

@@ -6,10 +6,10 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.03.02 19:00:00                  #
+# Updated Date: 2025.08.23 21:00:00                  #
 # ================================================== #
 
-MULTIMODAL_TEXT = "text"
-MULTIMODAL_IMAGE = "image"
 MULTIMODAL_AUDIO = "audio"
+MULTIMODAL_IMAGE = "image"
+MULTIMODAL_TEXT = "text"
 MULTIMODAL_VIDEO = "video"

pygpt_net/core/types/openai.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.08 19:00:00                  #
+# Updated Date: 2025.08.24 03:00:00                  #
 # ================================================== #
 
 OPENAI_COMPATIBLE_PROVIDERS = [
@@ -17,6 +17,7 @@ OPENAI_COMPATIBLE_PROVIDERS = [
     "huggingface_router",
     "local_ai",
     "mistral_ai",
+    "ollama",
     "perplexity",
     "deepseek_api",
     "x_ai",

pygpt_net/data/config/config.json

@@ -1,8 +1,8 @@
 {
   "__meta__": {
-    "version": "2.6.19",
-    "app.version": "2.6.19",
-    "updated_at": "2025-08-22T00:00:00"
+    "version": "2.6.21",
+    "app.version": "2.6.21",
+    "updated_at": "2025-08-24T00:00:00"
   },
   "access.audio.event.speech": false,
   "access.audio.event.speech.disabled": [],
@@ -63,6 +63,7 @@
   "agent.mode": "chat",
   "agent.openai.provider": "openai_agent_base",
   "agent.openai.response.split": true,
+  "agent.output.render.all": true,
   "ai_name": "",
   "api_azure_version": "2023-07-01-preview",
   "api_azure_endpoint": "https://<your-resource-name>.openai.azure.com/",
@@ -221,7 +222,6 @@
   "llama.idx.auto": false,
   "llama.idx.auto.index": "base",
   "llama.idx.auto.modes": "chat,completion,vision,assistant,research,llama_index,agent",
-  "llama.idx.chat.agent.render.all": false,
   "llama.idx.chat.auto_retrieve": true,
   "llama.idx.chat.mode": "context",
   "llama.idx.current": null,