sciveo 0.1.90__tar.gz → 0.1.91__tar.gz

{sciveo-0.1.90 → sciveo-0.1.91}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sciveo
-Version: 0.1.90
+Version: 0.1.91
 Description-Content-Type: text/markdown
 Provides-Extra: mon
 Provides-Extra: net

sciveo-0.1.91/sciveo/agents/base.py

@@ -0,0 +1,241 @@
+#
+# Pavlin Georgiev, Softel Labs
+#
+# This is a proprietary file and may not be copied,
+# distributed, or modified without express permission
+# from the owner. For licensing inquiries, please
+# contact pavlin@softel.bg.
+#
+# 2026
+#
+
+import json
+from sciveo.tools.logger import *
+
+
+# =========================
+# Agent IR (Anthropic-style)
+# =========================
+
+class ToolCall:
+  def __init__(self, name: str, input: dict):
+    self.name = name
+    self.input = input
+
+
+class AgentBlock:
+  def __init__(self, block_type: str, content):
+    self.type = block_type      # "text" | "tool_use"
+    self.content = content
+
+
+def parse_agent_blocks(raw_result) -> list:
+  """
+  Strict JSON-only parser.
+  Expected format: Anthropic-style block array.
+  """
+  try:
+    if isinstance(raw_result, str):
+      raw = json.loads(raw_result)
+    elif isinstance(raw_result, list):
+      raw = raw_result
+    else:
+        raise ValueError(f"Invalid type from LLM: {type(raw_result)}")
+  except Exception as e:
+    raise ValueError(f"Invalid JSON from LLM: {e}")
+
+  if not isinstance(raw, list):
+    raise ValueError("Top-level JSON must be a list")
+
+  blocks = []
+
+  for item in raw:
+    if not isinstance(item, dict):
+      raise ValueError("Each block must be an object")
+
+    block_type = item.get("type")
+
+    if block_type == "text":
+      blocks.append(
+        AgentBlock("text", item.get("text", ""))
+      )
+
+    elif block_type == "tool_use":
+      blocks.append(
+        AgentBlock(
+          "tool_use",
+          ToolCall(
+            name=item.get("name"),
+            input=item.get("input", {})
+          )
+        )
+      )
+
+    else:
+      raise ValueError(f"Unknown block type: {block_type}")
+
+  return blocks
+
+
+# =========================
+# Tools
+# =========================
+
+class ToolBase:
+  name = ""
+  description = ""
+
+  def run(self, args: str, agent):
+    raise NotImplementedError
+
+
+class ToolHelp(ToolBase):
+  schema = {
+    "name": "help",
+    "description": "List available tools",
+    "input_schema": {
+      "type": "object",
+      "properties": {},
+      "required": [],
+    },
+  }
+
+  def run(self, args, agent):
+    return "\n".join(
+      f"{name}: {tool.schema.description}"
+      for name, tool in agent.tools.items()
+    )
+
+
+# =========================
+# LLM Client Base
+# =========================
+
+class LLMClientBase:
+  def chat(self, messages: list[dict], tools=None) -> str:
+    """
+    Must return a STRING containing ONLY valid JSON
+    matching the AgentBlock schema.
+    """
+    raise NotImplementedError
+
+
+# =========================
+# Agent Base
+# =========================
+
+class AgentBase:
+  def __init__(self, llm: LLMClientBase):
+    self.llm = llm
+    self.tools = {}
+    self.messages = []
+    self.system_prompt = "You are a coding assistant. Use tools to help the user. Be concise and careful!"
+    # self.system_prompt = self._build_system_prompt()
+
+  def register_tool(self, tool: ToolBase):
+    debug("register_tool", tool.schema)
+    self.tools[tool.schema["name"]] = tool
+
+  def call_tool(self, name: str, args):
+    debug("TOOL", name, "args", args)
+    tool = self.tools.get(name)
+    if tool is None:
+      return f"[Tool error] Unknown tool: {name}"
+    return tool.run(args, self)
+
+  def _build_system_prompt(self) -> str:
+    tools_list = "\n".join(
+      f"- {t.name}: {t.description}"
+      for t in self.tools.values()
+    )
+
+    return f"""
+          You are a cautious code agent.
+
+          You have access to the following tools:
+          {tools_list}
+
+          When responding, output ONLY valid JSON.
+          The response MUST be a JSON array of blocks.
+
+          Each block must be one of:
+
+          1) Tool call:
+          {{
+            "type": "tool_use",
+            "name": "<tool_name>",
+            "input": {{ "args": "<string>" }}
+          }}
+
+          2) Text:
+          {{
+            "type": "text",
+            "text": "<string>"
+          }}
+
+          Rules:
+          - Use double quotes only
+          - No markdown
+          - No explanations outside JSON
+          - JSON must parse with json.loads()
+          """.strip()
+
+  def clear(self):
+    self.messages = []
+
+  def loop(self, user_input: str, is_clear=True):
+    if is_clear:
+      self.clear()
+
+    if len(self.messages) == 0:
+      # debug("system_prompt", system_prompt)
+      self.messages.append({
+        "role": "user",
+        "content": self.system_prompt
+      })
+
+    self.messages.append({
+      "role": "user",
+      "content": user_input
+    })
+
+    while True:
+
+      response = self.llm.chat(self.messages, self.tools)
+
+      self.messages.append({
+        "role": "assistant",
+        "content": str(response)
+      })
+
+      try:
+        blocks = parse_agent_blocks(response)
+      except Exception as e:
+        exception(e)
+        return f"[Agent error] {e}"
+
+      tool_used = False
+      final_text = ""
+
+      for block in blocks:
+        if block.type == "text":
+          final_text = block.content
+
+        elif block.type == "tool_use":
+          tool_used = True
+          result = self.call_tool(
+            block.content.name,
+            block.content.input.get("command", "")
+          )
+
+          debug("TOOL RESULT", result)
+
+          # Tool results are fed back as plain text
+          self.messages.append({
+            "role": "user",
+            "content": str(result)
+          })
+
+      # Stop when model stops calling tools
+      if not tool_used:
+        return final_text

sciveo-0.1.91/sciveo/agents/clients/anthropic.py

@@ -0,0 +1,81 @@
+#
+# Pavlin Georgiev, Softel Labs
+#
+# This is a proprietary file and may not be copied,
+# distributed, or modified without express permission
+# from the owner. For licensing inquiries, please
+# contact pavlin@softel.bg.
+#
+# 2026
+#
+
+import json
+from anthropic import Anthropic
+from sciveo.tools.logger import *
+from sciveo.agents.base import LLMClientBase
+
+
+class AnthropicClient(LLMClientBase):
+  """
+  Anthropic client using Messages API with native tool support.
+  Accepts structured tools list, handles tool_use and text blocks.
+  """
+
+  def __init__(self, api_key: str, model: str = "claude-sonnet-4-20250514", max_tokens: int = 4096, temperature: float = 0.2):
+    """
+    Initialize Anthropic Messages API client.
+    """
+    self.client = Anthropic(api_key=api_key)
+    self.model = model
+    self.max_tokens = max_tokens
+    self.temperature = temperature
+
+  def chat(self, messages: list[dict], tools=None) -> list[dict]:
+    """
+    Send messages to Claude with optional tools.
+    messages: [{"role": "user|assistant", "content": "..."}]
+    tools: [{"name": str, "description": str, "input_schema": dict}, ...]
+    Returns: list of blocks [{"type": "text|tool_use", ...}, ...]
+    """
+    try:
+      message_tools = []
+      for tn, T in tools.items():
+        message_tools.append(T.schema)
+
+      resp = self.client.messages.create(
+        model=self.model,
+        messages=messages,
+        tools=message_tools,
+        max_tokens=self.max_tokens,
+        temperature=self.temperature
+      )
+
+      # resp.content is a list of TextBlock or ToolUseBlock
+      blocks = []
+      for block in resp.content:
+        if block.type == "text":
+          try:
+            json_blocks = json.loads(block.text)
+            for json_block in json_blocks:
+              blocks.append({
+                "type": json_block["type"],
+                "name": json_block["name"],
+                "input": json_block["input"]
+              })
+          except Exception:
+            blocks.append({"type": "text", "text": block.text})
+        elif block.type == "tool_use":
+          blocks.append({
+            "type": "tool_use",
+            "name": block.name,
+            "input": block.input
+          })
+        else:
+          # Fallback: treat unknown blocks as text
+          blocks.append({"type": "text", "text": str(block)})
+
+      debug("AnthropicClient blocks", blocks)
+      return blocks
+
+    except Exception as e:
+      return [{"type": "text", "text": f"[Anthropic error] {e}"}]

sciveo-0.1.91/sciveo/agents/clients/gemini.py

@@ -0,0 +1,67 @@
+#
+# Pavlin Georgiev, Softel Labs
+#
+# This is a proprietary file and may not be copied,
+# distributed, or modified without express permission
+# from the owner. For licensing inquiries, please
+# contact pavlin@softel.bg.
+#
+# 2026
+#
+
+from google import genai
+from google.genai import types
+from sciveo.tools.logger import *
+from sciveo.agents.base import LLMClientBase
+
+
+class GeminiClient(LLMClientBase):
+  def __init__(
+    self,
+    api_key: str,
+    model: str = "gemini-2.5-flash",
+    temperature: float = 0.2,
+    max_output_tokens: int = 4096,
+  ):
+    """
+    Uses the new google-genai SDK.
+    """
+    # Create the unified GenAI client
+    self.client = genai.Client(api_key=api_key)
+    self.model = model
+    self.temperature = temperature
+    self.max_output_tokens = max_output_tokens
+
+  def chat(self, messages: list[dict], tools: list[dict] = None) -> str:
+    """
+    messages: list of {"role": "user"|"assistant", "content": "..."}
+    returns: plain text
+    """
+    try:
+      # Build a single prompt from history
+      # (GenAI `generate_content` is stateless, so we combine messages manually)
+      prompt = ""
+      for m in messages:
+        # We treat 'assistant' as plain continuation too
+        role = m["role"]
+        content = m["content"]
+        prompt += f"{role}: {content}\n"
+
+      # Call the GenAI text generation
+      response = self.client.models.generate_content(
+        model=self.model,
+        contents=types.Part.from_text(prompt),
+        config=types.GenerateContentConfig(
+          temperature=self.temperature,
+          max_output_tokens=self.max_output_tokens,
+        ),
+      )
+
+      # `response.text` contains the full generated output
+      text_out = response.text.strip()
+
+      debug("GeminiClient", {"model": self.model, "text": text_out})
+      return text_out
+
+    except Exception as e:
+      return f"[Gemini error] {e}"

sciveo-0.1.91/sciveo/agents/clients/groq.py

@@ -0,0 +1,36 @@
+#
+# Pavlin Georgiev, Softel Labs
+#
+# This is a proprietary file and may not be copied,
+# distributed, or modified without express permission
+# from the owner. For licensing inquiries, please
+# contact pavlin@softel.bg.
+#
+# 2026
+#
+
+from groq import Groq
+from sciveo.tools.logger import *
+from sciveo.agents.base import LLMClientBase
+
+
+class GroqClient(LLMClientBase):
+  def __init__(self, api_key, model="llama-3.3-70b-versatile", temperature=0.2, max_tokens=4096):
+    self.client = Groq(api_key=api_key)
+    self.model = model
+    self.temperature = temperature
+    self.max_tokens = max_tokens
+
+  def chat(self, messages: list[dict], tools: list[dict] = None) -> str:
+    try:
+      completion = self.client.chat.completions.create(
+        model=self.model,
+        messages=messages,
+        temperature=self.temperature,
+        max_tokens=self.max_tokens
+      )
+
+      return completion.choices[0].message.content.strip()
+
+    except Exception as e:
+      return f"[Groq error] {e}"

sciveo-0.1.91/sciveo/agents/console.py

@@ -0,0 +1,66 @@
+#
+# Pavlin Georgiev, Softel Labs
+#
+# This is a proprietary file and may not be copied,
+# distributed, or modified without express permission
+# from the owner. For licensing inquiries, please
+# contact pavlin@softel.bg.
+#
+# 2026
+#
+
+from sciveo.tools.logger import *
+from sciveo.agents.base import *
+from sciveo.agents.tools.os import *
+
+
+class BaseConsole:
+  def __init__(self, agent):
+    self.agent = agent
+
+  def run(self):
+    print("Sciveo Agent Console (type 'exit' to quit)")
+    while True:
+      try:
+        user_input = input("> ").strip()
+        if user_input.lower() in ("exit", "quit"):
+          break
+        if len(user_input) < 2:
+          continue
+
+        output = self.agent.loop(user_input)
+
+        if output:
+          info(output)
+      except KeyboardInterrupt:
+        info("exit")
+        break
+
+
+class TestAgent(AgentBase):
+  def __init__(self, llm: LLMClientBase):
+    super().__init__(llm)
+
+    self.register_tool(ToolReadFile())
+    self.register_tool(ToolWriteFile())
+    self.register_tool(ToolPathList())
+    self.register_tool(ToolBash())
+    self.register_tool(ToolHelp())
+
+
+if __name__ == "__main__":
+  from sciveo.agents.clients.gemini import GeminiClient
+  from sciveo.agents.clients.groq import GroqClient
+  from sciveo.agents.clients.anthropic import AnthropicClient
+
+  def create_code_agent():
+    # llm1 = GeminiClient(api_key=os.getenv("API_KEY_GEMINI"), model="models/gemini-2.5-flash")
+    # llm2 = GroqClient(api_key=os.getenv("API_KEY_GROQ"), model="llama-3.1-8b-instant")
+    # llm2 = GroqClient(api_key=os.getenv("API_KEY_GROQ"), model="llama-3.3-70b-versatile")
+    llm3 = AnthropicClient(api_key=os.getenv("API_KEY_ANTHROPIC"), model="claude-sonnet-4-20250514")
+    agent = TestAgent(llm3)
+
+    return agent
+
+  agent = create_code_agent()
+  BaseConsole(agent).run()

sciveo-0.1.91/sciveo/agents/tools/os.py

@@ -0,0 +1,115 @@
+#
+# Pavlin Georgiev, Softel Labs
+#
+# This is a proprietary file and may not be copied,
+# distributed, or modified without express permission
+# from the owner. For licensing inquiries, please
+# contact pavlin@softel.bg.
+#
+# 2026
+#
+
+import os
+import subprocess
+
+from sciveo.tools.logger import *
+from sciveo.agents.base import ToolBase
+
+
+class ToolReadFile(ToolBase):
+  schema = {
+    "name": "read_file",
+    "description": "Read contents of a file",
+    "input_schema": {
+      "type": "object",
+      "properties": {
+        "path": { "type": "string", "description": "File path to read" },
+      },
+      "required": ["path"],
+    }
+  }
+
+  def run(self, args, agent):
+    path = args
+    if not os.path.exists(path):
+      return f"File not found: {path}"
+    try:
+      with open(path, "r", encoding="utf-8") as f:
+        return f.read()
+    except Exception as e:
+      return f"Error reading file: {e}"
+    return f"FAIL: {args}"
+
+
+class ToolWriteFile(ToolBase):
+  schema = {
+    "name": "write_file",
+    "description": "Write content to a file",
+    "input_schema": {
+      "type": "object",
+      "properties": {
+        "path": { "type": "string", "description": "File path to write" },
+        "content": { "type": "string", "description": "Content to write" },
+      },
+      "required": ["path", "content"],
+    }
+  }
+
+  def run(self, args, agent):
+    path, content = args
+
+    try:
+      with open(path, "w", encoding="utf-8") as f:
+        f.write(content)
+      return f"Written: {path}"
+    except Exception as e:
+      return f"Error writing file: {e}"
+
+
+class ToolPathList(ToolBase):
+  schema = {
+    "name": "list_dir",
+    "description": "List directory contents",
+    "input_schema": {
+      "type": "object",
+      "properties": {
+        "path": { "type": "string", "description": "Directory path" },
+      },
+      "required": ["path"],
+    },
+  }
+
+  def run(self, args, agent):
+    path = args
+    try:
+      return "\n".join(os.listdir(path))
+    except Exception as e:
+      return f"Error listing directory: {e}"
+
+
+class ToolBash(ToolBase):
+  schema = {
+    "name": "bash",
+    "description": "Run a shell command",
+    "input_schema": {
+      "type": "object",
+      "properties": {
+        "command": { "type": "string", "description": "Command to run" },
+      },
+      "required": ["command"],
+    },
+  }
+
+  def run(self, args: str, agent):
+    try:
+      result = subprocess.run(
+        args,
+        shell=True,
+        capture_output=True,
+        text=True
+      )
+      out = result.stdout.strip()
+      err = result.stderr.strip()
+      return out if out else err if err else "OK"
+    except Exception as e:
+      return f"Bash error: {e}"

{sciveo-0.1.90 → sciveo-0.1.91}/sciveo/cli.py

@@ -60,15 +60,17 @@ def main():
   parser.add_argument('--execute', type=str, default=None, help='Execute command')
   parser.add_argument('--pid', type=int, default=None, help='Process PID')
   parser.add_argument('--serial', type=str, default=None, help='Serial Name')
-  parser.add_argument('--data-json', type=str, default="{}", help='Json Data')
+  parser.add_argument('--data-json', type=json.loads, default={}, help='Json Data')
   parser.add_argument('--display', type=int, default=None, help='Display number')
+  parser.add_argument('--list-shell', type=json.loads, default=[], help='List of Shell commands')
+  parser.add_argument('--list-logs', type=json.loads, default=[], help='List of Log files')
 
   args = parser.parse_args()
 
   if args.command == 'monitor':
     if args.src is None:
       from sciveo.monitoring.start import MonitorStart
-      MonitorStart(period=args.period, block=args.block, output_path=args.output_path)()
+      MonitorStart(period=args.period, block=args.block, output_path=args.output_path, shell=args.list_shell, logs=args.list_logs)()
     elif args.src.startswith("power"):
       from sciveo.monitoring.power.ems300 import PowerEMS300
       mon = PowerEMS300(serial=args.serial, host=args.host, port=args.port, period=args.period, output_path=args.output_path)
@@ -124,7 +126,7 @@ def main():
         else:
           # warning("RTSP src", args.src, "not recognised")
           server = CamFactory(args.src, args.width, args.height, args.fps, configuration=data, display=args.display)
-        server.serve(host=args.host, port=args.port, stream=args.stream)
+      server.serve(host=args.host, port=args.port, stream=args.stream)
   elif args.command == 'capture':
     from sciveo.media.capture.cam import CameraDaemon, ScreenDaemon, CapturePlayer
     if args.src == "screen":