NPC Functions

class Agent(NPC):
    """NPC with a default tool set (sh, python, edit_file, load_file, web_search, file_search, stop, chat).

    Can also load agent definitions from:
    - agents.md files (markdown with agent specs)
    - skills directories (each skill is a jinx)
    - MCP servers (external tool providers)
    """

    def __init__(
        self,
        name: str = "agent",
        primary_directive: str = "You are a helpful AI agent with access to tools.",
        model: str = None,
        provider: str = None,
        tools: list = None,
        extra_tools: list = None,
        agents_md: str = None,
        skills_dir: str = None,
        mcp_servers: list = None,
        safe_tools: bool = False,
        **kwargs,
    ):
        _EXEC_TOOLS = {_tool_sh, _tool_python}
        all_tools = [t for t in _DEFAULT_AGENT_TOOLS if not safe_tools or t not in _EXEC_TOOLS]
        if extra_tools:
            all_tools.extend(extra_tools)
        if tools is not None:
            all_tools = tools

        super().__init__(
            name=name,
            primary_directive=primary_directive,
            model=model,
            provider=provider,
            tools=all_tools,
            **kwargs,
        )

        if mcp_servers:
            self.mcp_servers = mcp_servers

        if agents_md:
            self._load_agents_md(agents_md)

        if skills_dir:
            self._load_skills_dir(skills_dir)

    def _load_agents_md(self, path: str):
        """Load agent definitions from an agents.md file.

        Format: markdown with H2 headings as agent names, body as directives.
        """
        path = os.path.expanduser(path)
        if not os.path.exists(path):
            return

        with open(path, 'r') as f:
            content = f.read()

        current_name = None
        current_body = []
        agents = {}

        for line in content.split('\n'):
            if line.startswith('## '):
                if current_name:
                    agents[current_name] = '\n'.join(current_body).strip()
                current_name = line[3:].strip()
                current_body = []
            elif current_name is not None:
                current_body.append(line)

        if current_name:
            agents[current_name] = '\n'.join(current_body).strip()

        self._sub_agents = agents

    def _load_skills_dir(self, path: str):
        """Load skills (jinxes) from a directory and add them as tools."""
        path = os.path.expanduser(path)
        if not os.path.isdir(path):
            return

        for fname in os.listdir(path):
            if fname.endswith('.jinx'):
                fpath = os.path.join(path, fname)
                try:
                    jinx = Jinx(jinx_path=fpath)
                    self.jinxes_dict[jinx.jinx_name] = jinx
                except Exception as e:
                    print(f"Warning: Failed to load skill {fname}: {e}")

    def run(
        self,
        input_text: str,
        max_iterations: int = 10,
        verbose: bool = False,
        require_permission: bool = True,
        allow_tools: list = None,
        **kwargs,
    ):
        """Run the agent in a tool-calling loop until it stops calling tools.

        Each iteration: call the model with tools; if it emits tool_calls, execute
        them and feed the results back; if it emits plain content, return it.

        Args:
            input_text: initial user prompt.
            max_iterations: hard cap on tool-calling turns.
            verbose: print each turn's tool calls and results.
            require_permission: if True (default), prompt the user before each
                tool call. Answer [y]es / [n]o / [a]ll (allow the rest of this
                run). Non-TTY environments auto-allow so scripts don't hang.
            allow_tools: optional list of tool names that bypass the prompt.
        """
        import sys
        import json as _json
        import uuid as _uuid
        from npcpy.llm_funcs import get_llm_response

        messages = list(kwargs.get("messages", []) or [])
        stream = kwargs.get("stream", False)
        prompt = input_text
        last_content = ""
        allow_tools = set(allow_tools or [])
        approve_all = [False]
        is_tty = sys.stdin.isatty()

        def _log(msg):
            if verbose:
                print(msg, flush=True)

        def _ask(tool_name, args):
            if not require_permission or tool_name in allow_tools or approve_all[0]:
                return True
            if not is_tty:
                _log(f"[agent:{self.name}] non-TTY: auto-allow {tool_name}")
                return True
            args_str = str(args)
            if len(args_str) > 300:
                args_str = args_str[:300] + "…"
            print(f"\n[agent:{self.name}] allow tool: {tool_name}({args_str})?", flush=True)
            resp = input("  [y]es / [n]o / [a]ll: ").strip().lower()
            if resp == "a":
                approve_all[0] = True
                return True
            return resp.startswith("y")

        def _extract_tc(tc):
            if isinstance(tc, dict):
                tc_id = tc.get("id") or str(_uuid.uuid4())
                fn = tc.get("function", {}) or {}
                name = fn.get("name", "")
                args_raw = fn.get("arguments", "{}")
            else:
                tc_id = getattr(tc, "id", None) or str(_uuid.uuid4())
                fn_obj = getattr(tc, "function", None)
                name = getattr(fn_obj, "name", "") if fn_obj else ""
                args_raw = getattr(fn_obj, "arguments", "{}") if fn_obj else "{}"
            if isinstance(args_raw, str):
                try:
                    args = _json.loads(args_raw)
                except (_json.JSONDecodeError, TypeError):
                    args = {"raw_arguments": args_raw}
            else:
                args = args_raw or {}
            return tc_id, name, args

        _log(f"[agent:{self.name}] run start | model={self.model} provider={self.provider} | prompt={input_text!r}")

        for iteration in range(max_iterations):
            _log(f"[agent:{self.name}] iter {iteration+1}/{max_iterations} → calling model")
            result = get_llm_response(
                prompt,
                npc=self,
                model=self.model,
                provider=self.provider,
                tools=self.tools,
                tool_map=self.tool_map,
                messages=messages,
                stream=stream,
            )
            if not isinstance(result, dict):
                return str(result)

            tool_calls = result.get("tool_calls")
            content = result.get("output", result.get("response", "")) or ""
            if content:
                last_content = content

            if not tool_calls:
                _log(f"[agent:{self.name}] no tool_calls → returning content ({len(last_content)} chars)")
                return last_content

            messages = result.get("messages", messages)
            # Drop the empty assistant turn get_ollama_response appends when the
            # model only emitted tool_calls — we'll add a proper one below.
            if (messages and messages[-1].get("role") == "assistant"
                    and not messages[-1].get("content")
                    and "tool_calls" not in messages[-1]):
                messages = messages[:-1]

            extracted = [_extract_tc(tc) for tc in tool_calls]
            _log(f"[agent:{self.name}] tool_calls: {[name for _, name, _ in extracted]}")

            messages.append({
                "role": "assistant",
                "content": None,
                "tool_calls": [
                    {
                        "id": tc_id,
                        "type": "function",
                        "function": {"name": name, "arguments": args},
                    }
                    for tc_id, name, args in extracted
                ],
            })

            for tc_id, name, args in extracted:
                if not _ask(name, args):
                    result_str = "[permission denied by user]"
                elif name in self.tool_map:
                    try:
                        tool_result = self.tool_map[name](**args)
                        result_str = _json.dumps(tool_result, default=str) if not isinstance(tool_result, str) else tool_result
                    except Exception as e:
                        result_str = f"Error executing {name}: {e}"
                else:
                    result_str = f"Unknown tool: {name}"

                messages.append({
                    "role": "tool",
                    "tool_call_id": tc_id,
                    "content": result_str,
                })

                disp_args = str(args)
                disp_res = result_str
                if len(disp_args) > 200:
                    disp_args = disp_args[:200] + "…"
                if len(disp_res) > 400:
                    disp_res = disp_res[:400] + "…"
                _log(f"[agent:{self.name}]   → {name}({disp_args}) = {disp_res}")

            prompt = None

        _log(f"[agent:{self.name}] hit max_iterations={max_iterations}")
        return last_content or "Max iterations reached without a final answer."

class CLIAgent(Agent):
    """Agent that runs CLI tools (claude, opencode, kimi, kilo) as subprocesses.

    Session context is managed by npcsh via temp files tied to conversation_id.
    """

    CLI_COMMANDS = {
        "claude_code": ["claude"],
        "claude": ["claude"],
        "opencode": ["opencode", "run"],
        "kimi_code": ["kimi"],
        "kimi": ["kimi"],
        "kilo_code": ["kilo", "run"],
        "kilo": ["kilo", "run"],
        "npcsh": ["npcsh"],
        "gemini": ["gemini"],
        "codex": ["codex"],
        "nanocoder": ["nanocoder"],
    }

    def __init__(
        self,
        cli_provider: str,
        name: str = "cli_agent",
        primary_directive: str = None,
        model: str = None,
        session_file: str = None,
        **kwargs,
    ):
        if primary_directive is None:
            primary_directive = f"CLI agent using {cli_provider} for code tasks."

        kwargs.pop("provider", None)
        super().__init__(
            name=name,
            primary_directive=primary_directive,
            model=model,
            provider=cli_provider,
            **kwargs,
        )

        self.cli_provider = cli_provider
        self.session_file = session_file

    def run(self, input_text: str, verbose: bool = False, session_context: str = None, **kwargs):
        from npcpy.gen.cli_agent import run_cli_agent

        full_prompt = f"{session_context}\n\n{input_text}" if session_context else input_text
        return run_cli_agent(
            provider=self.cli_provider,
            prompt=full_prompt,
            model=self.model,
            system_prompt=self.primary_directive,
            session_id=kwargs.get("session_id"),
            history=kwargs.get("messages"),
            images=kwargs.get("images"),
            think=kwargs.get("think"),
            n_samples=kwargs.get("n_samples", 1),
            verbose=verbose,
        )

class CodingAgent(Agent):
    """Agent that auto-detects + executes code blocks in LLM responses."""

    def __init__(
        self,
        name: str = "coding_agent",
        primary_directive: str = None,
        language: str = "python",
        auto_execute: bool = True,
        model: str = None,
        provider: str = None,
        **kwargs,
    ):
        if primary_directive is None:
            primary_directive = (
                f"You are a coding agent specialized in {language}. "
                f"Write {language} code in fenced code blocks (```{language}). "
                "The code will be automatically executed and the output fed back to you."
            )

        super().__init__(
            name=name,
            primary_directive=primary_directive,
            model=model,
            provider=provider,
            **kwargs,
        )

        self.language = language
        self.auto_execute = auto_execute

    def extract_code_blocks(self, text: str) -> list:
        """Extract code blocks matching this agent's language."""
        pattern = re.compile(r"```(\w+)?\s*\n(.*?)```", re.DOTALL)
        blocks = []
        for match in pattern.finditer(text):
            lang = (match.group(1) or "").lower()
            code = match.group(2).strip()
            if lang == self.language.lower() or (not lang and self.language == "python"):
                blocks.append(code)
        return blocks

    def execute_code(self, code: str) -> str:
        """Execute a code block and return the output."""
        lang = self.language.lower()
        if lang == "python":
            return _tool_python(code)
        elif lang in ("bash", "sh", "shell"):
            return _tool_sh(code)
        elif lang in ("javascript", "js", "node"):
            try:
                result = subprocess.run(
                    ["node", "-e", code], capture_output=True, text=True, timeout=120
                )
                out = result.stdout
                if result.returncode != 0 and result.stderr:
                    out += f"\nSTDERR:\n{result.stderr}"
                return out or "(no output)"
            except Exception as e:
                return f"Error: {e}"
        else:
            return f"Execution not supported for language: {lang}"

    def run(self, input_text: str, **kwargs):
        """Run with auto-execution of code blocks."""
        from npcpy.llm_funcs import get_llm_response

        messages = kwargs.get("messages", [])
        max_rounds = kwargs.get("max_rounds", 5)
        current_input = input_text
        response_text = ""

        for _ in range(max_rounds):
            result = get_llm_response(
                current_input,
                npc=self,
                model=self.model,
                provider=self.provider,
                tools=self.tools,
                tool_map=self.tool_map,
                messages=messages,
                stream=kwargs.get("stream", False),
            )

            if isinstance(result, dict):
                response_text = result.get("output", result.get("response", str(result)))
                messages = result.get("messages", messages)
            else:
                response_text = str(result)

            if not self.auto_execute:
                return response_text

            code_blocks = self.extract_code_blocks(response_text)
            if not code_blocks:
                return response_text

            execution_results = []
            for i, code in enumerate(code_blocks, 1):
                output = self.execute_code(code)
                execution_results.append(f"[Block {i} output]:\n{output}")

            current_input = "Code execution results:\n" + "\n\n".join(execution_results)

        return response_text

class Jinx:
    ''' 
    Jinx represents a workflow template with Jinja-rendered steps.

    Loads YAML definition containing:
    - jinx_name: identifier
    - inputs: list of input parameters
    - description: what the jinx does
    - npc: optional NPC to execute with
    - steps: list of step definitions with code. This section can now be a Jinja template itself.
    - file_context: optional list of file patterns to include as context

    Execution:
    - Renders Jinja templates in step code with input values
    - Executes resulting Python code
    - Returns context with outputs
    '''
    def __init__(self, jinx_data=None, jinx_path=None):
        if jinx_path:
            self._load_from_file(jinx_path)
        elif jinx_data:
            self._load_from_data(jinx_data)
        else:
            raise ValueError("Either jinx_data or jinx_path must be provided")

        self._raw_steps = list(self.steps)
        if self.steps and all(isinstance(s, dict) for s in self.steps):
            pass
        else:
            self.steps = []
        self.parsed_files = {}
        if self.file_context:
            self.parsed_files = self._parse_file_patterns(self.file_context)

    def _load_from_file(self, path):
        jinx_data = load_yaml_file(path)
        if not jinx_data:
            raise ValueError(f"Failed to load jinx from {path}")
        jinx_data['_source_path'] = path
        self._load_from_data(jinx_data)


    def _load_from_data(self, jinx_data):
        if not jinx_data or not isinstance(jinx_data, dict):
            raise ValueError("Invalid jinx data provided")

        if "jinx_name" not in jinx_data:
            raise KeyError("Missing 'jinx_name' in jinx definition")

        self.jinx_name = jinx_data.get("jinx_name")
        self.inputs = jinx_data.get("inputs", [])
        self.description = jinx_data.get("description", "")
        self.npc = jinx_data.get("npc")
        self.steps = jinx_data.get("steps", [])
        self.file_context = jinx_data.get("file_context", [])
        self._source_path = jinx_data.get("_source_path", None)

    def to_tool_def(self) -> Dict[str, Any]:
        """Convert this Jinx to an OpenAI-style tool definition."""
        properties = {}
        required = []
        for inp in self.inputs:
            if isinstance(inp, str):
                properties[inp] = {"type": "string", "description": f"Parameter: {inp}"}
                required.append(inp)
            elif isinstance(inp, dict):
                name = list(inp.keys())[0]
                default_val = inp.get(name, "")
                desc = f"Parameter: {name}"
                if default_val != "":
                    desc += f" (default: {default_val})"
                properties[name] = {"type": "string", "description": desc}
        return {
            "type": "function",
            "function": {
                "name": self.jinx_name,
                "description": self.description or f"Jinx: {self.jinx_name}",
                "parameters": {
                    "type": "object",
                    "properties": properties,
                    "required": required
                }
            }
        }

    def render_first_pass(
        self,
        jinja_env_for_macros: Environment,
        all_jinx_callables: Dict[str, Callable]
    ):
        """
        Performs the first-pass Jinja rendering on the Jinx's raw steps.
        This expands Jinja control flow (for, if) to generate step structures,
        then expands nested Jinx calls (e.g., {{ sh(...) }} or engine: jinx_name)
        and inline macros.
        """
        if self._raw_steps and isinstance(self._raw_steps[0], dict):
            structurally_expanded_steps = list(self._raw_steps)
        else:
            raw_steps_template_string = "\n".join(self._raw_steps)

            try:
                steps_template = jinja_env_for_macros.from_string(raw_steps_template_string)
                rendered_steps_yaml_string = steps_template.render(**jinja_env_for_macros.globals)
            except Exception as e:
                self.steps = list(self._raw_steps)
                return

            try:
                structurally_expanded_steps = yaml.safe_load(rendered_steps_yaml_string)
                if not isinstance(structurally_expanded_steps, list):
                    if structurally_expanded_steps is None:
                        structurally_expanded_steps = []
                    else:
                        raise ValueError(f"Rendered steps YAML did not result in a list: {type(structurally_expanded_steps)}")
            except Exception as e:
                self.steps = list(self._raw_steps)
                return

        final_rendered_steps = []
        for raw_step in structurally_expanded_steps:
            if not isinstance(raw_step, dict):
                final_rendered_steps.append(raw_step)
                continue

            engine_name = raw_step.get('engine')

            if engine_name and engine_name in all_jinx_callables:
                step_name = raw_step.get('name', f'call_{engine_name}')
                jinx_args = {
                    k: v for k, v in raw_step.items() 
                    if k not in ['engine', 'name']
                }

                jinx_callable = all_jinx_callables[engine_name]
                try:
                    expanded_yaml_string = jinx_callable(**jinx_args)
                    expanded_steps = yaml.safe_load(expanded_yaml_string)

                    if isinstance(expanded_steps, list):
                        final_rendered_steps.extend(expanded_steps)
                    elif expanded_steps is not None:
                        final_rendered_steps.append(expanded_steps)
                except Exception as e:
                    final_rendered_steps.append(raw_step)
            elif raw_step.get('engine') in ['python', 'bash']:
                processed_step = {}
                for key, value in raw_step.items():
                    if isinstance(value, str):
                        has_template_var = '{{' in value and '}}' in value
                        if has_template_var:
                            processed_step[key] = value
                        else:
                            try:
                                template = jinja_env_for_macros.from_string(value)
                                rendered_value = template.render({})
                                try:
                                    loaded_value = yaml.safe_load(rendered_value)
                                    processed_step[key] = loaded_value
                                except yaml.YAMLError:
                                    processed_step[key] = rendered_value
                            except Exception as e:
                                processed_step[key] = value
                    else:
                        processed_step[key] = value
                final_rendered_steps.append(processed_step)
            else:
                processed_step = {}
                for key, value in raw_step.items():
                    if isinstance(value, str):
                        try:
                            template = jinja_env_for_macros.from_string(value)
                            rendered_value = template.render({})
                            try:
                                loaded_value = yaml.safe_load(rendered_value)
                                processed_step[key] = loaded_value
                            except yaml.YAMLError:
                                processed_step[key] = rendered_value
                        except Exception as e:
                            processed_step[key] = value
                    else:
                        processed_step[key] = value
                final_rendered_steps.append(processed_step)

        self.steps = final_rendered_steps

    def execute(self,
                input_values: Dict[str, Any],
                npc: Optional[Any] = None,
                messages: Optional[List[Dict[str, str]]] = None,
                extra_globals: Optional[Dict[str, Any]] = None,
                jinja_env: Optional[Environment] = None):

        if jinja_env is None:
            jinja_env = SandboxedEnvironment(
                loader=DictLoader({}),
                undefined=SilentUndefined,
            )

        active_npc = self.npc if self.npc else npc

        # If npc is a list or NPCArray, run this jinx in parallel across all instances
        from npcpy.npc_array import NPCArray
        if isinstance(active_npc, (list, NPCArray)):
            arr = NPCArray.from_npcs(active_npc) if isinstance(active_npc, list) else active_npc
            return arr.jinx(self.jinx_name, inputs=input_values).collect()

        context = (
            active_npc.shared_context.copy() 
            if active_npc and hasattr(active_npc, 'shared_context') 
            else {}
        )
        context.update(input_values)
        context.update({
            "llm_response": None,
            "output": None,
            "messages": messages,
            "npc": active_npc
        })

        if self.parsed_files:
            context['file_context'] = self._format_parsed_files_context(self.parsed_files)
            context['files'] = self.parsed_files

        for i, step in enumerate(self.steps):
            context = self._execute_step(
                step,
                context,
                jinja_env,
                npc=active_npc,
                messages=messages,
                extra_globals=extra_globals
            )
            output_str = str(context.get("output", ""))
            if "error" in output_str.lower():
                break

        return context

    def _execute_step(self,
                  step: Dict[str, Any],
                  context: Dict[str, Any],
                  jinja_env: Environment,
                  npc: Optional[Any] = None,
                  messages: Optional[List[Dict[str, str]]] = None,
                  extra_globals: Optional[Dict[str, Any]] = None):

        step_name = step.get("name", "unnamed_step")
        step_npc = step.get("npc")
        active_npc = step_npc if step_npc else npc

        code_content = step.get("code") or ""

        try:
            template = jinja_env.from_string(code_content)
            rendered_code = template.render(**context)
        except Exception as e:
            error_msg = f"Error rendering template for step '{step_name}' (second pass): {type(e).__name__}: {e}"
            context['output'] = error_msg
            return context

        from npcpy.npc_array import NPCArray, infer_matrix, ensemble_vote

        exec_globals = {
            "__builtins__": __builtins__,
            "npc": active_npc,
            "context": context,
            "math": math,
            "random": random,
            "datetime": datetime,
            "Image": Image,
            "pd": pd,
            "plt": plt,
            "sys": sys,
            "subprocess": subprocess,
            "np": np,
            "os": os,
            're': re,
            "json": json,
            "Path": pathlib.Path,
            "fnmatch": fnmatch,
            "pathlib": pathlib,
            "subprocess": subprocess,
            "get_llm_response": npy.llm_funcs.get_llm_response,
            "print_and_process_stream_with_markdown": print_and_process_stream_with_markdown,
            "NPCArray": NPCArray,
            "infer_matrix": infer_matrix,
            "ensemble_vote": ensemble_vote,
        }

        if extra_globals:
            exec_globals.update(extra_globals)

        exec_globals.update(context)

        exec_locals = exec_globals

        try:
            exec(rendered_code, exec_globals, exec_locals)
        except SystemExit as e:
            error_msg = f"Error executing step '{step_name}' in jinx '{self.jinx_name}': code called sys.exit({e.code})"
            print(f"[JINX-ERROR] {error_msg}")
            context['output'] = error_msg
            return context
        except Exception as e:
            error_msg = f"Error executing step '{step_name}' in jinx '{self.jinx_name}': {type(e).__name__}: {e}"
            print(f"[JINX-ERROR] {error_msg}")
            context['output'] = error_msg
            return context

        context_output = context.get("output")
        context.update(exec_locals)

        if context_output is not None:
            context["output"] = context_output
            context[step_name] = context_output

        if "output" in exec_locals and exec_locals["output"] is not None:
            outp = exec_locals["output"]
            context["output"] = outp
            context[step_name] = outp

        final_output = context.get("output")
        if final_output and messages is not None:
            messages.append({
                'role':'assistant',
                'content': f'Jinx {self.jinx_name} step {step_name} executed: {final_output}'
            })
            context['messages'] = messages

        return context

    def _parse_file_patterns(self, patterns_config):
        """Parse file patterns configuration and load matching files into KV cache"""
        if not patterns_config:
            return {}

        file_cache = {}

        for pattern_entry in patterns_config:
            if isinstance(pattern_entry, str):
                pattern_entry = {"pattern": pattern_entry}

            pattern = pattern_entry.get("pattern", "")
            recursive = pattern_entry.get("recursive", False)
            base_path = pattern_entry.get("base_path", ".")

            if not pattern:
                continue

            if self._source_path:
                base_path = os.path.join(os.path.dirname(self._source_path), base_path)
            base_path = os.path.expanduser(base_path)

            if not os.path.isabs(base_path):
                base_path = os.path.join(os.getcwd(), base_path)

            matching_files = self._find_matching_files(pattern, base_path, recursive)

            for file_path in matching_files:
                file_content = self._load_file_content(file_path)
                if file_content:
                    relative_path = os.path.relpath(file_path, base_path)
                    file_cache[relative_path] = file_content

        return file_cache

    def _find_matching_files(self, pattern, base_path, recursive=False):
        """Find files matching the given pattern"""
        matching_files = []

        if not os.path.exists(base_path):
            return matching_files

        if recursive:
            for root, dirs, files in os.walk(base_path):
                for filename in files:
                    if fnmatch.fnmatch(filename, pattern):
                        matching_files.append(os.path.join(root, filename))
        else:
            try:
                for item in os.listdir(base_path):
                    item_path = os.path.join(base_path, item)
                    if os.path.isfile(item_path) and fnmatch.fnmatch(item, pattern):
                        matching_files.append(item_path)
            except PermissionError:
                print(f"Permission denied accessing {base_path}")

        return matching_files

    def _load_file_content(self, file_path):
        """Load content from a file with error handling"""
        try:
            with open(file_path, 'r', encoding='utf-8') as f:
                return f.read()
        except Exception as e:
            print(f"Error reading {file_path}: {e}")
            return None

    def _format_parsed_files_context(self, parsed_files):
        """Format parsed files into context string"""
        if not parsed_files:
            return ""

        context_parts = ["Additional context from files:"]

        for file_path, content in parsed_files.items():
            context_parts.append(f"\n--- {file_path} ---")
            context_parts.append(content)
            context_parts.append("")

        return "\n".join(context_parts)

    def to_dict(self):
        result = {
            "jinx_name": self.jinx_name,
            "description": self.description,
            "inputs": self.inputs,
            "steps": self._raw_steps,
            "file_context": self.file_context
        }

        if self.npc:
            result["npc"] = self.npc

        return result

    def save(self, directory):
        jinx_path = os.path.join(directory, f"{self.jinx_name}.jinx")
        ensure_dirs_exist(os.path.dirname(jinx_path))
        return write_yaml_file(jinx_path, self.to_dict())

    @classmethod
    def from_mcp(cls, mcp_tool):
        try:
            import inspect

            doc = mcp_tool.__doc__ or ""
            name = mcp_tool.__name__
            signature = inspect.signature(mcp_tool)

            inputs = []
            for param_name, param in signature.parameters.items():
                if param_name != 'self':
                    param_type = (
                        param.annotation 
                        if param.annotation != inspect.Parameter.empty 
                        else None
                    )
                    param_default = (
                        None 
                        if param.default == inspect.Parameter.empty 
                        else param.default
                    )

                    inputs.append({
                        "name": param_name,
                        "type": str(param_type),
                        "default": param_default
                    })

            jinx_data = {
                "jinx_name": name,
                "description": doc.strip(),
                "inputs": inputs,
                "file_context": [],
                "steps": [
                    {
                        "name": "mcp_function_call",
                        "code": f"""
import {mcp_tool.__module__}
output = {mcp_tool.__module__}.{name}(
    {', '.join([
        f'{inp["name"]}=context.get("{inp["name"]}")' 
        for inp in inputs
    ])}
)
"""
                    }
                ]
            }

            return cls(jinx_data=jinx_data)

        except: 
            pass