minimax-code-sdk 0.1.0b1__py3-none-any.whl

minimax_code/__init__.py

@@ -0,0 +1,66 @@
+"""Python SDK for driving the local MiniMax Code (``mcode``) agent."""
+
+from .client import MCode
+from .errors import (
+    MCODE_EXEC_EXIT_CODES,
+    MCodeAbortError,
+    MCodeError,
+    MCodeInvocationError,
+    MCodeNotFoundError,
+    MCodeProtocolError,
+    MCodeRunError,
+    MCodeVersionError,
+    ThreadBusyError,
+)
+from .sync import SyncMCode, SyncThread
+from .thread import StreamedTurn, Thread
+from .types import (
+    AgentMessageItem,
+    ExecError,
+    ExecItem,
+    ExecResult,
+    MCodeOptions,
+    ModelIdentity,
+    ReasoningItem,
+    RunOptions,
+    ThreadEvent,
+    ThreadItem,
+    ThreadOptions,
+    ToolCallItem,
+    Turn,
+    Usage,
+)
+
+__version__ = "0.1.0b1"
+
+__all__ = [
+    "MCODE_EXEC_EXIT_CODES",
+    "AgentMessageItem",
+    "ExecError",
+    "ExecItem",
+    "ExecResult",
+    "MCode",
+    "MCodeAbortError",
+    "MCodeError",
+    "MCodeInvocationError",
+    "MCodeNotFoundError",
+    "MCodeOptions",
+    "MCodeProtocolError",
+    "MCodeRunError",
+    "MCodeVersionError",
+    "ModelIdentity",
+    "ReasoningItem",
+    "RunOptions",
+    "StreamedTurn",
+    "SyncMCode",
+    "SyncThread",
+    "Thread",
+    "ThreadBusyError",
+    "ThreadEvent",
+    "ThreadItem",
+    "ThreadOptions",
+    "ToolCallItem",
+    "Turn",
+    "Usage",
+    "__version__",
+]

minimax_code/_args.py

@@ -0,0 +1,90 @@
+"""Builds ``mcode exec`` argv. Mirrors ``packages/code-sdk/src/args.ts``."""
+
+from __future__ import annotations
+
+import os
+
+from .errors import MCodeInvocationError
+from .types import RunOptions, ThreadOptions
+
+_PERMISSIONS = {"smart", "full", "off"}
+_MODES = {"standard", "lightweight"}
+_PROMPT_MODES = {"tui", "coding", "work"}
+MAX_TIMEOUT_MS = 2**31 - 1
+
+
+def validate_thread_options(options: ThreadOptions, resuming: bool) -> None:
+    if options.permission is not None and options.permission not in _PERMISSIONS:
+        raise MCodeInvocationError(
+            f"permission must be smart, full or off; received {options.permission!r}."
+        )
+    if options.mode is not None and options.mode not in _MODES:
+        raise MCodeInvocationError(
+            f"mode must be standard or lightweight; received {options.mode!r}."
+        )
+    if resuming and options.mode == "lightweight":
+        raise MCodeInvocationError(
+            'mode "lightweight" requires a new Thread; it cannot be resumed.'
+        )
+    if options.prompt_mode is not None and options.prompt_mode not in _PROMPT_MODES:
+        raise MCodeInvocationError(
+            f"prompt_mode must be tui, coding or work; received {options.prompt_mode!r}."
+        )
+
+
+def _positive_int(value: object) -> bool:
+    return isinstance(value, int) and not isinstance(value, bool) and value > 0
+
+
+def validate_run_options(options: RunOptions) -> None:
+    if options.timeout_ms is not None and (
+        not _positive_int(options.timeout_ms) or options.timeout_ms > MAX_TIMEOUT_MS
+    ):
+        raise MCodeInvocationError(
+            f"timeout_ms must be a positive integer no greater than {MAX_TIMEOUT_MS}."
+        )
+    if options.max_steps is not None and not _positive_int(options.max_steps):
+        raise MCodeInvocationError("max_steps must be a positive integer.")
+
+
+def build_exec_args(
+    *,
+    thread: ThreadOptions,
+    session_id: str | None,
+    run: RunOptions,
+    config_path: str | None = None,
+    system_prompt_file: str | None = None,
+    append_system_prompt_file: str | None = None,
+) -> list[str]:
+    """The prompt travels over stdin and system prompts through temp files; values use the
+    ``--flag=value`` form so a value starting with ``-`` is never parsed as a flag."""
+    args = [
+        "exec",
+        "--output-format=stream-json",
+        "--input=-",
+        "--input-format=json",
+        f"--cwd={os.path.abspath(thread.cwd or os.getcwd())}",
+    ]
+
+    def push(flag: str, value: str | None) -> None:
+        if value is not None:
+            args.append(f"{flag}={value}")
+
+    push("--model", thread.model)
+    push("--effort", thread.effort)
+    push("--permission", thread.permission)
+    push("--prompt-mode", thread.prompt_mode)
+    push("--config", config_path)
+    if session_id is None:
+        push("--mode", thread.mode)
+    else:
+        push("--session", session_id)
+    push("--system-prompt-file", system_prompt_file)
+    push("--append-system-prompt-file", append_system_prompt_file)
+    for file in run.files:
+        push("--file", file)
+    if run.timeout_ms is not None:
+        push("--timeout", f"{run.timeout_ms}ms")
+    if run.max_steps is not None:
+        push("--max-steps", str(run.max_steps))
+    return args

minimax_code/_cli.py

@@ -0,0 +1,87 @@
+"""Locates and version-checks the ``mcode`` CLI."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import re
+import shutil
+from collections.abc import Mapping
+from dataclasses import dataclass
+
+from .errors import MCODE_INSTALL_HINT, MCodeNotFoundError, MCodeVersionError
+
+MIN_CLI_VERSION = (0, 6, 3)
+_JS_SUFFIXES = (".js", ".mjs", ".cjs")
+
+
+@dataclass(frozen=True)
+class ResolvedCli:
+    path: str
+
+    def command(self, args: list[str]) -> list[str]:
+        if self.path.endswith(_JS_SUFFIXES):
+            node = shutil.which("node") or "node"
+            return [node, self.path, *args]
+        return [self.path, *args]
+
+
+def resolve_cli(bin: str | None, env: Mapping[str, str]) -> ResolvedCli:
+    """Explicit ``bin`` → ``$MCODE_BIN`` → ``mcode`` on ``PATH``."""
+    explicit = bin or env.get("MCODE_BIN") or None
+    if explicit:
+        path = os.path.abspath(os.path.expanduser(explicit))
+        if not os.path.isfile(path):
+            source = "bin" if bin else "MCODE_BIN"
+            raise MCodeNotFoundError(f"mcode CLI from {source} does not exist: {path}")
+        return ResolvedCli(path)
+    found = shutil.which("mcode", path=env.get("PATH", os.defpath))
+    if not found:
+        raise MCodeNotFoundError(
+            "Could not find the mcode CLI on PATH. Install it with "
+            f"`{MCODE_INSTALL_HINT}`, set MCODE_BIN, or pass MCodeOptions(bin=...)."
+        )
+    return ResolvedCli(found)
+
+
+def parse_version(text: str) -> tuple[int, int, int] | None:
+    match = re.search(r"(\d+)\.(\d+)\.(\d+)", text)
+    if not match:
+        return None
+    major, minor, patch = (int(part) for part in match.groups())
+    return (major, minor, patch)
+
+
+async def check_cli_version(cli: ResolvedCli, env: Mapping[str, str]) -> str:
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            *cli.command(["--version"]),
+            stdin=asyncio.subprocess.DEVNULL,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            env=dict(env),
+        )
+        out, err = await asyncio.wait_for(proc.communicate(), timeout=30)
+    except (OSError, asyncio.TimeoutError) as error:
+        raise MCodeNotFoundError(f"Could not run `{cli.path} --version`: {error}") from error
+    if proc.returncode != 0:
+        raise MCodeVersionError(
+            f"`mcode --version` failed ({proc.returncode}); cannot verify CLI compatibility.",
+            exit_code=proc.returncode,
+            stderr=err.decode("utf-8", "replace"),
+        )
+    text = out.decode("utf-8", "replace")
+    version = parse_version(text)
+    if version is None:
+        raise MCodeVersionError(f"Could not read the mcode version from: {text.strip()!r}.")
+    if version < MIN_CLI_VERSION:
+        minimum = ".".join(map(str, MIN_CLI_VERSION))
+        found = ".".join(map(str, version))
+        raise MCodeVersionError(
+            f"mcode {found} is older than the minimum {minimum} required by minimax-code-sdk. "
+            f"Upgrade with `{MCODE_INSTALL_HINT}`."
+        )
+    return ".".join(map(str, version))
+
+
+__all__ = ["ResolvedCli", "check_cli_version", "resolve_cli"]

minimax_code/_items.py

@@ -0,0 +1,71 @@
+"""Folds ``item.*`` events into SDK items. Mirrors ``packages/code-sdk/src/items.ts``."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Any
+
+from .types import AgentMessageItem, ReasoningItem, ThreadEvent, ThreadItem, ToolCallItem
+
+
+@dataclass
+class _State:
+    type: str
+    text: str = ""
+    tool_call: dict[str, Any] | None = None
+    completed: bool = False
+    snapshot: str = ""
+
+
+class ItemAccumulator:
+    def __init__(self) -> None:
+        self._states: dict[str, _State] = {}
+
+    def apply(self, event: ThreadEvent) -> bool:
+        """Applies one event. Returns False for a duplicate snapshot ``item.updated``."""
+        if event["type"] not in ("item.started", "item.updated", "item.completed"):
+            return True
+        item = event.get("item")
+        if item is None:
+            return True
+        delta = item.get("contentDelta")
+        snapshot = json.dumps(item, sort_keys=True) if delta is None else ""
+        state = self._states.get(item["id"])
+        if (
+            state is not None
+            and event["type"] == "item.updated"
+            and snapshot
+            and state.snapshot == snapshot
+            and not state.completed
+        ):
+            return False
+        if state is None:
+            state = _State(type=item["type"])
+            self._states[item["id"]] = state
+        state.snapshot = snapshot
+        if delta is not None:
+            state.text += delta
+        if "content" in item:
+            state.text = item["content"]
+        if "toolCall" in item:
+            state.tool_call = item["toolCall"]
+        if event["type"] == "item.completed":
+            state.completed = True
+        return True
+
+    def items(self) -> list[ThreadItem]:
+        out: list[ThreadItem] = []
+        for item_id, s in self._states.items():
+            incomplete = not s.completed
+            if s.type == "agent_message":
+                out.append(AgentMessageItem(id=item_id, text=s.text, incomplete=incomplete))
+            elif s.type == "reasoning":
+                out.append(ReasoningItem(id=item_id, text=s.text, incomplete=incomplete))
+            elif s.type == "tool_call":
+                out.append(
+                    ToolCallItem(
+                        id=item_id, tool_call=s.tool_call or {"id": item_id}, incomplete=incomplete
+                    )
+                )
+        return out

minimax_code/_protocol.py

@@ -0,0 +1,56 @@
+"""Parses stdout lines. Mirrors ``packages/code-sdk/src/protocol.ts``."""
+
+from __future__ import annotations
+
+import json
+from typing import Any, cast
+
+from .errors import MCodeProtocolError, MCodeVersionError
+from .types import ThreadEvent
+
+SUPPORTED_SCHEMA_VERSION = 1
+
+
+def _truncate(text: str) -> str:
+    return text if len(text) <= 200 else text[:200] + "…"
+
+
+def parse_event_line(line: str) -> ThreadEvent | None:
+    text = line.strip()
+    if not text:
+        return None
+    try:
+        value: Any = json.loads(text)
+    except json.JSONDecodeError as error:
+        raise MCodeProtocolError(f"mcode stdout is not JSON: {_truncate(text)}") from error
+    if not isinstance(value, dict):
+        raise MCodeProtocolError(f"mcode stdout line is not a JSON object: {_truncate(text)}")
+    if value.get("schemaVersion") != SUPPORTED_SCHEMA_VERSION:
+        raise MCodeVersionError(
+            f"Unsupported mcode event schemaVersion {value.get('schemaVersion')!r}; "
+            f"this SDK supports {SUPPORTED_SCHEMA_VERSION}."
+        )
+    if not isinstance(value.get("type"), str) or not isinstance(value.get("sessionId"), str):
+        raise MCodeProtocolError(f"mcode event is missing type or sessionId: {_truncate(text)}")
+    kind: str = value["type"]
+    if kind.startswith("item."):
+        item = value.get("item")
+        if not (
+            isinstance(item, dict)
+            and isinstance(item.get("id"), str)
+            and isinstance(item.get("type"), str)
+        ):
+            raise MCodeProtocolError(f"mcode {kind} event has an invalid item: {_truncate(text)}")
+    if kind == "exec.completed":
+        result = value.get("result")
+        if not (
+            isinstance(result, dict)
+            and result.get("schemaVersion") == SUPPORTED_SCHEMA_VERSION
+            and isinstance(result.get("status"), str)
+            and isinstance(result.get("sessionId"), str)
+            and isinstance(result.get("turnId"), str)
+        ):
+            raise MCodeProtocolError(
+                f"mcode exec.completed has an invalid result: {_truncate(text)}"
+            )
+    return cast(ThreadEvent, value)

minimax_code/client.py

@@ -0,0 +1,61 @@
+"""Entry point. Mirrors ``packages/code-sdk/src/mcode.ts``."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+
+from ._args import validate_thread_options
+from ._cli import ResolvedCli, check_cli_version, resolve_cli
+from .errors import MCodeInvocationError
+from .thread import Thread, ThreadHost
+from .types import MCodeOptions, ThreadOptions
+
+
+class MCode:
+    """One client resolves and version-checks the CLI once, then starts Threads."""
+
+    def __init__(self, options: MCodeOptions | None = None) -> None:
+        self._options = options or MCodeOptions()
+        self._cli: ResolvedCli | None = None
+        self._lock: asyncio.Lock | None = None
+        config = self._options.config_path
+        self._host = ThreadHost(
+            config_path=os.path.abspath(config) if config else None,
+            child_env=self._child_env,
+            prepare_cli=self._prepare_cli,
+        )
+
+    def start_thread(self, options: ThreadOptions | None = None) -> Thread:
+        """Starts a new Thread. The Session is created by its first Turn."""
+        options = options or ThreadOptions()
+        validate_thread_options(options, resuming=False)
+        return Thread(self._host, options, None)
+
+    def resume_thread(self, thread_id: str, options: ThreadOptions | None = None) -> Thread:
+        """Continues an existing Session, for example one persisted from ``thread.id``."""
+        if not isinstance(thread_id, str) or not thread_id.strip():
+            raise MCodeInvocationError("resume_thread requires a non-empty Session id.")
+        options = options or ThreadOptions()
+        validate_thread_options(options, resuming=True)
+        return Thread(self._host, options, thread_id.strip())
+
+    def _child_env(self) -> dict[str, str]:
+        env = dict(self._options.env if self._options.env is not None else os.environ)
+        if self._options.data_dir is not None:
+            env["MINIMAX_DATA_DIR"] = os.path.abspath(self._options.data_dir)
+        return env
+
+    async def _prepare_cli(self) -> ResolvedCli:
+        if self._cli is not None:
+            return self._cli
+        if self._lock is None:
+            self._lock = asyncio.Lock()
+        async with self._lock:
+            if self._cli is None:
+                env = self._child_env()
+                cli = resolve_cli(self._options.bin, env)
+                await check_cli_version(cli, env)
+                # Only cached on success, so a later run works after installing the CLI.
+                self._cli = cli
+            return self._cli

minimax_code/errors.py

@@ -0,0 +1,139 @@
+"""SDK errors. Mirrors ``packages/code-sdk/src/errors.ts``."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+
+from .types import ExecResult, ThreadItem
+
+#: Exit codes of ``mcode exec`` (``MINIMAX_CODE_EXEC_EXIT_CODES`` in the CLI).
+MCODE_EXEC_EXIT_CODES: dict[str, int] = {
+    "success": 0,
+    "invocation": 2,
+    "config": 3,
+    "runtime": 4,
+    "timeout": 6,
+    "limit": 7,
+    "internal": 70,
+    "cancelled": 130,
+    "broken_pipe": 141,
+}
+
+MCODE_INSTALL_HINT = "npm install -g @minimax-ai/code@latest"
+
+
+class MCodeError(Exception):
+    """Base class for every error raised by the SDK."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        exit_code: int | None = None,
+        stderr: str = "",
+        session_id: str | None = None,
+        result: ExecResult | None = None,
+        items: Sequence[ThreadItem] = (),
+    ) -> None:
+        super().__init__(message)
+        self.exit_code = exit_code
+        #: Tail of the CLI stderr, for diagnostics only.
+        self.stderr = stderr
+        self.session_id = session_id
+        self.result = result
+        self.items = list(items)
+
+
+class MCodeInvocationError(MCodeError):
+    """Invalid SDK options, or the CLI rejected the invocation (exit code 2)."""
+
+
+class MCodeRunError(MCodeError):
+    """The Turn ended with ``failed``, ``timeout`` or ``limit_exceeded``."""
+
+    def __init__(self, message: str, *, status: str, category: str | None = None, **kw: Any):
+        super().__init__(message, **kw)
+        self.status = status
+        self.category = category
+
+
+class MCodeAbortError(MCodeError):
+    """The Turn was cancelled."""
+
+
+class MCodeProtocolError(MCodeError):
+    """The CLI produced output the SDK cannot understand."""
+
+
+class MCodeNotFoundError(MCodeError):
+    """The ``mcode`` CLI could not be found."""
+
+
+class MCodeVersionError(MCodeError):
+    """The CLI is too old or speaks an unsupported schema version."""
+
+
+class ThreadBusyError(MCodeError):
+    """A Thread already has a Turn in progress."""
+
+    def __init__(self, thread_id: str | None) -> None:
+        super().__init__(f"Thread {thread_id or '(new)'} already has a Turn in progress.")
+
+
+_STATUS_BY_EXIT_CODE: dict[int, tuple[str, str | None]] = {
+    3: ("failed", "config"),
+    4: ("failed", "runtime"),
+    6: ("timeout", None),
+    7: ("limit_exceeded", None),
+    70: ("failed", "internal"),
+}
+
+
+def error_for_result(
+    result: ExecResult, items: Sequence[ThreadItem], *, exit_code: int | None, stderr: str
+) -> MCodeError:
+    common: dict[str, Any] = {
+        "exit_code": exit_code,
+        "stderr": stderr,
+        "session_id": result["sessionId"],
+        "result": result,
+        "items": items,
+    }
+    if result["status"] == "cancelled":
+        return MCodeAbortError("The MCode run was cancelled.", **common)
+    status = "failed" if result["status"] == "succeeded" else result["status"]
+    error = result.get("error")
+    reason = error["message"] if error else f"status {result['status']}"
+    category = error["category"] if error else None
+    return MCodeRunError(
+        f"The MCode run ended with {status}: {reason}", status=status, category=category, **common
+    )
+
+
+def error_for_exit(
+    *, exit_code: int | None, stderr: str, items: Sequence[ThreadItem], session_id: str | None
+) -> MCodeError:
+    lines = [line.strip() for line in stderr.splitlines() if line.strip()]
+    reason = lines[-1] if lines else f"exit code {exit_code}"
+    common: dict[str, Any] = {
+        "exit_code": exit_code,
+        "stderr": stderr,
+        "items": items,
+        "session_id": session_id,
+    }
+    if exit_code == MCODE_EXEC_EXIT_CODES["invocation"]:
+        return MCodeInvocationError(f"mcode rejected the invocation: {reason}", **common)
+    if exit_code == MCODE_EXEC_EXIT_CODES["cancelled"] or (exit_code is not None and exit_code < 0):
+        return MCodeAbortError("The MCode run was cancelled.", **common)
+    if exit_code == MCODE_EXEC_EXIT_CODES["broken_pipe"]:
+        return MCodeProtocolError(f"mcode reported a broken output pipe: {reason}", **common)
+    if exit_code == 0:
+        return MCodeProtocolError("mcode exited without emitting exec.completed.", **common)
+    status, category = _STATUS_BY_EXIT_CODE.get(exit_code or -1, ("failed", "internal"))
+    return MCodeRunError(
+        f"The MCode run ended without a result: {reason}",
+        status=status,
+        category=category,
+        **common,
+    )

minimax_code/sync.py

@@ -0,0 +1,64 @@
+"""Blocking wrappers around the async API, for scripts and notebooks without an event loop."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Iterator
+from typing import Any
+
+from .client import MCode
+from .thread import Thread
+from .types import MCodeOptions, RunOptions, ThreadEvent, ThreadOptions, Turn
+
+
+class SyncThread:
+    def __init__(self, loop: asyncio.AbstractEventLoop, thread: Thread) -> None:
+        self._loop = loop
+        self._thread = thread
+
+    @property
+    def id(self) -> str | None:
+        return self._thread.id
+
+    def run(self, input: str, options: RunOptions | None = None) -> Turn:
+        return self._loop.run_until_complete(self._thread.run(input, options))
+
+    def run_streamed(self, input: str, options: RunOptions | None = None) -> Iterator[ThreadEvent]:
+        """Yields events; closing the iterator early cancels the Turn."""
+        streamed = self._loop.run_until_complete(self._thread.run_streamed(input, options))
+        events = streamed.events
+        try:
+            while True:
+                try:
+                    yield self._loop.run_until_complete(events.__anext__())
+                except StopAsyncIteration:
+                    return
+        finally:
+            self._loop.run_until_complete(streamed.aclose())
+
+
+class SyncMCode:
+    """Blocking client. Owns a private event loop; call ``close()`` (or use ``with``) when done."""
+
+    def __init__(self, options: MCodeOptions | None = None) -> None:
+        self._loop = asyncio.new_event_loop()
+        self._client = MCode(options)
+
+    def start_thread(self, options: ThreadOptions | None = None) -> SyncThread:
+        return SyncThread(self._loop, self._client.start_thread(options))
+
+    def resume_thread(self, thread_id: str, options: ThreadOptions | None = None) -> SyncThread:
+        return SyncThread(self._loop, self._client.resume_thread(thread_id, options))
+
+    def close(self) -> None:
+        if not self._loop.is_closed():
+            # Let subprocess transports finish closing before the loop goes away.
+            self._loop.run_until_complete(asyncio.sleep(0.05))
+            self._loop.run_until_complete(self._loop.shutdown_asyncgens())
+            self._loop.close()
+
+    def __enter__(self) -> SyncMCode:
+        return self
+
+    def __exit__(self, *exc: Any) -> None:
+        self.close()

minimax_code/thread.py

@@ -0,0 +1,331 @@
+"""Threads and Turns. Mirrors ``packages/code-sdk/src/thread.ts`` and ``exec-process.ts``.
+
+The SDK holds only the Session id: every Turn starts a new ``mcode exec`` process and continues
+the Session with ``--session``.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import json
+import os
+import shutil
+import signal
+import sys
+import tempfile
+from collections.abc import AsyncIterator, Awaitable, Callable
+from types import TracebackType
+from typing import Any
+
+from ._args import build_exec_args, validate_run_options
+from ._cli import ResolvedCli
+from ._items import ItemAccumulator
+from ._protocol import parse_event_line
+from .errors import (
+    MCodeError,
+    MCodeNotFoundError,
+    MCodeProtocolError,
+    ThreadBusyError,
+    error_for_exit,
+    error_for_result,
+)
+from .types import ExecResult, RunOptions, ThreadEvent, ThreadOptions, Turn
+
+STDERR_TAIL_BYTES = 64 * 1024
+CANCEL_GRACE_S = 10.0
+BACKSTOP_EXTRA_S = 30.0
+_STDOUT_LINE_LIMIT = 64 * 1024 * 1024
+
+
+class ThreadHost:
+    """What a Thread needs from its owning client."""
+
+    def __init__(
+        self,
+        *,
+        config_path: str | None,
+        child_env: Callable[[], dict[str, str]],
+        prepare_cli: Callable[[], Awaitable[ResolvedCli]],
+    ) -> None:
+        self.config_path = config_path
+        self.child_env = child_env
+        self.prepare_cli = prepare_cli
+
+
+class StreamedTurn:
+    """Events of one running Turn. Iterate with ``async for``; leaving the loop early (``break``,
+    an exception, or task cancellation) cancels the Turn and waits for the CLI to exit."""
+
+    def __init__(
+        self,
+        events: AsyncIterator[ThreadEvent],
+        cancel: Callable[[], None],
+        finalize: Callable[[], Awaitable[None]],
+    ) -> None:
+        self.events = events
+        self._cancel = cancel
+        self._finalize = finalize
+
+    def __aiter__(self) -> AsyncIterator[ThreadEvent]:
+        return self.events
+
+    def cancel(self) -> None:
+        """Asks the CLI to stop (SIGINT). The stream then ends with the CLI's final events."""
+        self._cancel()
+
+    async def aclose(self) -> None:
+        """Stops the Turn if it is still running and releases the Thread."""
+        aclose = getattr(self.events, "aclose", None)
+        if aclose is not None:
+            await aclose()
+        # Covers a stream that was never iterated, whose generator body never ran.
+        await self._finalize()
+
+    async def __aenter__(self) -> StreamedTurn:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        await self.aclose()
+
+
+class _Exec:
+    """One ``mcode exec`` child process."""
+
+    def __init__(self, proc: asyncio.subprocess.Process) -> None:
+        self.proc = proc
+        self.stderr_tail = ""
+        self._stderr_task = asyncio.ensure_future(self._drain_stderr())
+        self._interrupted = False
+
+    async def _drain_stderr(self) -> None:
+        assert self.proc.stderr is not None
+        while chunk := await self.proc.stderr.read(65536):
+            text = self.stderr_tail + chunk.decode("utf-8", "replace")
+            self.stderr_tail = text[-STDERR_TAIL_BYTES:]
+
+    def interrupt(self) -> None:
+        if self.proc.returncode is not None or self._interrupted:
+            return
+        self._interrupted = True
+        with contextlib.suppress(ProcessLookupError):
+            if sys.platform == "win32":
+                self.proc.terminate()
+            else:
+                self.proc.send_signal(signal.SIGINT)
+
+    async def shutdown(self, grace: float = CANCEL_GRACE_S) -> None:
+        """Interrupts a live CLI, then kills it after ``grace`` seconds."""
+        if self.proc.returncode is None:
+            self.interrupt()
+            try:
+                await asyncio.wait_for(asyncio.shield(self.proc.wait()), timeout=grace)
+            except asyncio.TimeoutError:
+                with contextlib.suppress(ProcessLookupError):
+                    self.proc.kill()
+                await self.proc.wait()
+        with contextlib.suppress(asyncio.TimeoutError):
+            await asyncio.wait_for(asyncio.shield(self._stderr_task), timeout=2)
+        # Close the pipes now, while the loop is alive; asyncio has no public API for this.
+        transport = getattr(self.proc, "_transport", None)
+        if transport is not None:
+            transport.close()
+
+
+class Thread:
+    """A conversation with the Agent."""
+
+    def __init__(self, host: ThreadHost, options: ThreadOptions, thread_id: str | None) -> None:
+        self._host = host
+        self._options = options
+        self._session_id = thread_id
+        self._busy = False
+
+    @property
+    def id(self) -> str | None:
+        """Session id. Available after the first event of the first Turn, even if it fails."""
+        return self._session_id
+
+    async def run(self, input: str, options: RunOptions | None = None) -> Turn:
+        """Runs one Turn. Returns only when it succeeds; otherwise raises an ``MCodeError``."""
+        state: dict[str, Any] = {}
+        result: ExecResult | None = None
+        streamed = await self._start(input, options or RunOptions(), state)
+        async with streamed:
+            async for event in streamed:
+                if event["type"] == "exec.completed" and "result" in event:
+                    result = event["result"]
+        if result is None:
+            raise MCodeProtocolError("mcode finished without exec.completed.")
+        acc: ItemAccumulator = state["items"]
+        items = acc.items()
+        if result["status"] != "succeeded":
+            raise error_for_result(
+                result, items, exit_code=state.get("exit_code"), stderr=state.get("stderr", "")
+            )
+        output = result.get("output")
+        final = output if isinstance(output, str) else "" if output is None else json.dumps(output)
+        return Turn(
+            final_response=final,
+            items=items,
+            session_id=result["sessionId"],
+            turn_id=result["turnId"],
+            duration_ms=result["durationMs"],
+            result=result,
+            usage=result.get("usage"),
+            model=result.get("model"),
+        )
+
+    async def run_streamed(self, input: str, options: RunOptions | None = None) -> StreamedTurn:
+        """Runs one Turn and yields CLI events as they arrive. ``turn.failed`` is an ordinary
+        event; iteration raises only for process or protocol failures."""
+        return await self._start(input, options or RunOptions(), {})
+
+    async def _start(self, input: str, options: RunOptions, state: dict[str, Any]) -> StreamedTurn:
+        if self._busy:
+            raise ThreadBusyError(self._session_id)
+        if not isinstance(input, str):
+            raise TypeError("input must be a string.")
+        validate_run_options(options)
+        self._busy = True
+        temp_dir: str | None = None
+        try:
+            cli = await self._host.prepare_cli()
+            prompt_files: dict[str, str] = {}
+            if self._options.system_prompt is not None or (
+                self._options.append_system_prompt is not None
+            ):
+                temp_dir = tempfile.mkdtemp(prefix="mcode-sdk-")
+                for key, text in (
+                    ("system_prompt_file", self._options.system_prompt),
+                    ("append_system_prompt_file", self._options.append_system_prompt),
+                ):
+                    if text is not None:
+                        path = os.path.join(temp_dir, key.replace("_file", "") + ".txt")
+                        fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
+                        with os.fdopen(fd, "w", encoding="utf-8") as fh:
+                            fh.write(text)
+                        prompt_files[key] = path
+            args = build_exec_args(
+                thread=self._options,
+                session_id=self._session_id,
+                run=options,
+                config_path=self._host.config_path,
+                **prompt_files,
+            )
+            try:
+                proc = await asyncio.create_subprocess_exec(
+                    *cli.command(args),
+                    stdin=asyncio.subprocess.PIPE,
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                    env=self._host.child_env(),
+                    limit=_STDOUT_LINE_LIMIT,
+                )
+            except OSError as error:
+                raise MCodeNotFoundError(f"Could not start mcode at {cli.path}: {error}") from error
+        except BaseException:
+            self._release(temp_dir)
+            raise
+        child = _Exec(proc)
+        released = False
+
+        def release() -> None:
+            nonlocal released
+            if not released:
+                released = True
+                self._release(temp_dir)
+
+        events = self._events(child, input, options, state, release)
+
+        async def finalize() -> None:
+            await _quiet_shutdown(child)
+            release()
+
+        return StreamedTurn(events, child.interrupt, finalize)
+
+    async def _events(
+        self,
+        child: _Exec,
+        prompt: str,
+        options: RunOptions,
+        state: dict[str, Any],
+        release: Callable[[], None],
+    ) -> AsyncIterator[ThreadEvent]:
+        items = ItemAccumulator()
+        state["items"] = items
+        completed = False
+        backstop: asyncio.TimerHandle | None = None
+        if options.timeout_ms is not None:
+            delay = options.timeout_ms / 1000 + BACKSTOP_EXTRA_S
+            backstop = asyncio.get_running_loop().call_later(delay, _kill, child.proc)
+        try:
+            assert child.proc.stdin is not None and child.proc.stdout is not None
+            with contextlib.suppress(BrokenPipeError, ConnectionResetError):
+                child.proc.stdin.write(json.dumps({"prompt": prompt}).encode("utf-8"))
+                await child.proc.stdin.drain()
+                child.proc.stdin.close()
+            line_no = 0
+            while True:
+                try:
+                    raw = await child.proc.stdout.readline()
+                except ValueError as error:
+                    raise MCodeProtocolError("mcode stdout line exceeds the size limit.") from error
+                if not raw:
+                    break
+                line_no += 1
+                try:
+                    event = parse_event_line(raw.decode("utf-8", "replace"))
+                except MCodeError as error:
+                    error.stderr = child.stderr_tail
+                    raise
+                if event is None:
+                    continue
+                if self._session_id is None:
+                    self._session_id = event["sessionId"]
+                if event["type"] == "exec.completed":
+                    completed = True
+                if items.apply(event):
+                    yield event
+            await child.proc.wait()
+            await child.shutdown()
+            state["exit_code"] = child.proc.returncode
+            state["stderr"] = child.stderr_tail
+            if not completed:
+                raise error_for_exit(
+                    exit_code=child.proc.returncode,
+                    stderr=child.stderr_tail,
+                    items=items.items(),
+                    session_id=self._session_id,
+                )
+        except BaseException:
+            await _quiet_shutdown(child)
+            raise
+        finally:
+            if backstop is not None:
+                backstop.cancel()
+            release()
+
+    def _release(self, temp_dir: str | None) -> None:
+        self._busy = False
+        if temp_dir:
+            shutil.rmtree(temp_dir, ignore_errors=True)
+
+
+def _kill(proc: asyncio.subprocess.Process) -> None:
+    if proc.returncode is None:
+        with contextlib.suppress(ProcessLookupError):
+            proc.kill()
+
+
+async def _quiet_shutdown(child: _Exec) -> None:
+    with contextlib.suppress(Exception):
+        await asyncio.shield(child.shutdown())
+
+
+__all__ = ["StreamedTurn", "Thread", "ThreadHost"]

minimax_code/types.py

@@ -0,0 +1,184 @@
+"""Public types for the ``mcode exec --output-format stream-json`` contract (schemaVersion 1).
+
+Mirrors ``packages/code-sdk/src/types.ts``. Events are passed through as plain dicts typed with
+``TypedDict`` so new fields or event types added by newer CLIs never break parsing.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Literal, TypedDict
+
+from typing_extensions import NotRequired
+
+ExecResultStatus = Literal["succeeded", "failed", "timeout", "cancelled", "limit_exceeded"]
+ExecErrorCategory = Literal["config", "runtime", "internal"]
+UsageSource = Literal["completed_responses", "analytics_fallback", "unavailable"]
+ExecItemType = Literal["agent_message", "reasoning", "tool_call"]
+PermissionPolicy = Literal["smart", "full", "off"]
+ContextMode = Literal["standard", "lightweight"]
+PromptMode = Literal["tui", "coding", "work"]
+
+
+class ExecError(TypedDict):
+    category: ExecErrorCategory
+    message: str
+    code: NotRequired[str]
+    retryable: NotRequired[bool]
+
+
+class ModelIdentity(TypedDict):
+    providerId: str
+    modelId: str
+    variant: NotRequired[str]
+    providerSource: NotRequired[str]
+    providerKind: NotRequired[str]
+    protocol: NotRequired[str]
+
+
+class Usage(TypedDict, total=False):
+    """Token usage. ``totalTokens = inputTokens + outputTokens``; cache buckets are separate."""
+
+    totalTokens: int
+    inputTokens: int
+    outputTokens: int
+    reasoningTokens: int
+    cacheReadTokens: int
+    cacheWriteTokens: int
+
+
+class ExecResult(TypedDict):
+    """Final result of one ``mcode exec`` run (``exec.completed.result``)."""
+
+    schemaVersion: Literal[1]
+    type: Literal["exec.result"]
+    runId: str
+    sessionId: str
+    turnId: str
+    status: ExecResultStatus
+    durationMs: int
+    output: NotRequired[Any]
+    error: NotRequired[ExecError]
+    model: NotRequired[ModelIdentity]
+    usage: NotRequired[Usage]
+    usageSource: NotRequired[UsageSource]
+    usageIncomplete: NotRequired[bool]
+
+
+RawToolCall = dict[str, Any]
+"""Experimental raw tool call snapshot (``id``, ``name``, ``status``, ``input``, ``output``...)."""
+
+
+class ExecItem(TypedDict):
+    id: str
+    type: ExecItemType
+    content: NotRequired[str]
+    contentDelta: NotRequired[str]
+    toolCall: NotRequired[RawToolCall]
+
+
+class ThreadEvent(TypedDict):
+    """One CLI stream event. Check ``type`` and read the fields specific to it.
+
+    Known types: ``exec.started``, ``session.started``, ``session.resumed``, ``turn.started``,
+    ``item.started``, ``item.updated``, ``item.completed`` (with ``item``), ``turn.completed``
+    (``model``/``usage``/``durationMs``), ``turn.failed`` (``status``/``error``/``durationMs``),
+    ``exec.completed`` (``result``). Unknown types are passed through; keep a default branch.
+    """
+
+    schemaVersion: Literal[1]
+    type: str
+    sequence: int
+    timestampMs: int
+    runId: str
+    sessionId: str
+    turnId: str
+    item: NotRequired[ExecItem]
+    result: NotRequired[ExecResult]
+    model: NotRequired[ModelIdentity]
+    usage: NotRequired[Usage]
+    usageSource: NotRequired[UsageSource]
+    usageIncomplete: NotRequired[bool]
+    status: NotRequired[str]
+    error: NotRequired[ExecError]
+    durationMs: NotRequired[int]
+
+
+@dataclass(frozen=True)
+class AgentMessageItem:
+    id: str
+    text: str
+    incomplete: bool = False
+    type: Literal["agent_message"] = "agent_message"
+
+
+@dataclass(frozen=True)
+class ReasoningItem:
+    id: str
+    text: str
+    incomplete: bool = False
+    type: Literal["reasoning"] = "reasoning"
+
+
+@dataclass(frozen=True)
+class ToolCallItem:
+    id: str
+    tool_call: RawToolCall
+    incomplete: bool = False
+    type: Literal["tool_call"] = "tool_call"
+
+
+ThreadItem = AgentMessageItem | ReasoningItem | ToolCallItem
+
+
+@dataclass(frozen=True)
+class Turn:
+    """Result of a successful ``thread.run()``."""
+
+    final_response: str
+    items: list[ThreadItem]
+    session_id: str
+    turn_id: str
+    duration_ms: int
+    result: ExecResult
+    usage: Usage | None = None
+    model: ModelIdentity | None = None
+    status: Literal["succeeded"] = "succeeded"
+
+
+@dataclass(frozen=True)
+class MCodeOptions:
+    """Client options.
+
+    ``bin``: explicit ``mcode`` executable (or JS entry). Otherwise ``$MCODE_BIN``, then ``PATH``.
+    ``data_dir``: passed to the CLI as ``MINIMAX_DATA_DIR``.
+    ``env``: child environment; replaces ``os.environ`` when provided.
+    ``config_path``: runtime config file, passed as ``--config``.
+    """
+
+    bin: str | None = None
+    data_dir: str | None = None
+    env: dict[str, str] | None = None
+    config_path: str | None = None
+
+
+@dataclass(frozen=True)
+class ThreadOptions:
+    cwd: str | None = None
+    model: str | None = None
+    """Model as ``provider/model``, for example ``minimax/MiniMax-M3``."""
+    effort: str | None = None
+    permission: PermissionPolicy | None = None
+    mode: ContextMode | None = None
+    """Context mode for a new Thread. ``lightweight`` cannot be resumed."""
+    prompt_mode: PromptMode | None = None
+    system_prompt: str | None = None
+    append_system_prompt: str | None = None
+
+
+@dataclass(frozen=True)
+class RunOptions:
+    files: list[str] = field(default_factory=list)
+    """Files attached to this Turn (``--file``). Relative paths resolve against ``cwd``."""
+    timeout_ms: int | None = None
+    max_steps: int | None = None

minimax_code_sdk-0.1.0b1.dist-info/METADATA

@@ -0,0 +1,139 @@
+Metadata-Version: 2.5
+Name: minimax-code-sdk
+Version: 0.1.0b1
+Summary: Python SDK for driving the local MiniMax Code (mcode) agent.
+Project-URL: Homepage, https://agent.minimax.io
+Project-URL: Repository, https://github.com/MiniMax-AI/minimax-code
+Project-URL: Issues, https://github.com/MiniMax-AI/minimax-code/issues
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agent,coding-agent,mcode,minimax,minimax-code,sdk
+Classifier: Development Status :: 4 - Beta
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: typing-extensions>=4.7
+Description-Content-Type: text/markdown
+
+# minimax-code-sdk
+
+Python SDK for driving the local [MiniMax Code](https://agent.minimax.io) agent (`mcode`).
+
+It mirrors the TypeScript SDK
+[`@minimax-ai/code-sdk`](https://github.com/MiniMax-AI/minimax-code/tree/main/packages/code-sdk): every Turn runs
+`mcode exec --output-format=stream-json` and continues the Session with `--session`.
+
+## Requirements
+
+- Python 3.10+
+- The `mcode` CLI (0.6.3 or newer): `npm install -g @minimax-ai/code`
+
+## Install
+
+```bash
+pip install --pre minimax-code-sdk   # or: uv add --prerelease=allow minimax-code-sdk
+```
+
+The SDK is in beta, so installers need `--pre` (or an exact version such as
+`minimax-code-sdk==0.1.0b1`) until `0.1.0` is released. Import it as `minimax_code`.
+
+The CLI is found from `MCodeOptions(bin=...)`, then the `MCODE_BIN` environment variable,
+then `PATH`.
+
+## Quick start
+
+```python
+import asyncio
+from minimax_code import MCode, ThreadOptions
+
+
+async def main() -> None:
+    client = MCode()
+    thread = client.start_thread(ThreadOptions(cwd=".", permission="smart"))
+
+    turn = await thread.run("Summarize this repository in one sentence.")
+    print(turn.final_response, turn.usage)
+
+    # Same Session, next Turn.
+    turn = await thread.run("Now list its top-level directories.")
+
+    # Persist thread.id and continue later.
+    later = client.resume_thread(thread.id)
+    print((await later.run("What did I ask first?")).final_response)
+
+
+asyncio.run(main())
+```
+
+### Streaming
+
+```python
+streamed = await thread.run_streamed("Fix the failing test.")
+async for event in streamed:
+    if event["type"] == "item.updated" and event["item"]["type"] == "agent_message":
+        print(event["item"].get("contentDelta", ""), end="")
+    elif event["type"] == "turn.failed":
+        print("failed:", event.get("error"))
+```
+
+Events are the CLI's stream-json events, passed through unchanged (unknown types included).
+`turn.failed` is an ordinary event; iteration raises only for process or protocol failures.
+
+### Cancellation
+
+- `streamed.cancel()` sends SIGINT; the stream ends with the CLI's final events.
+- Leaving the `async for` early, or cancelling the task running `thread.run()`, stops the CLI
+  (SIGINT, then SIGKILL after a grace period).
+- `RunOptions(timeout_ms=...)` is enforced by the CLI.
+
+### Blocking API
+
+```python
+from minimax_code import SyncMCode
+
+with SyncMCode() as client:
+    thread = client.start_thread()
+    print(thread.run("hello").final_response)
+    for event in thread.run_streamed("again"):
+        print(event["type"])
+```
+
+## Options
+
+| Object | Fields |
+| --- | --- |
+| `MCodeOptions` | `bin`, `data_dir` (`MINIMAX_DATA_DIR`), `env` (replaces `os.environ`), `config_path` |
+| `ThreadOptions` | `cwd`, `model` (`provider/model`), `effort`, `permission` (`smart`/`full`/`off`), `mode`, `prompt_mode`, `system_prompt`, `append_system_prompt` |
+| `RunOptions` | `files`, `timeout_ms`, `max_steps` |
+
+## Errors
+
+All errors subclass `MCodeError` (with `exit_code`, `stderr`, `session_id`, `result`, `items`):
+`MCodeNotFoundError`, `MCodeVersionError`, `MCodeInvocationError`, `MCodeRunError`
+(`status`, `category`), `MCodeAbortError`, `MCodeProtocolError`, `ThreadBusyError`.
+
+## Limitations
+
+Each Turn is a separate process, so interactive permission prompts (`permission="ask"`) and
+custom in-process tools are not supported yet. A long-lived ACP transport is planned.
+
+## Development
+
+```bash
+uv sync
+uv run pytest
+uv run ruff check . && uv run ruff format --check . && uv run mypy
+```
+
+End-to-end tests against a real CLI and model are opt-in:
+`MCODE_SDK_E2E=1 MCODE_BIN=/path/to/mcode uv run pytest -m e2e`.
+
+Release notes are in
+[CHANGELOG.md](https://github.com/MiniMax-AI/minimax-code/blob/main/packages/code-sdk-python/CHANGELOG.md);
+maintainers publish with
+[RELEASING.md](https://github.com/MiniMax-AI/minimax-code/blob/main/packages/code-sdk-python/RELEASING.md).
+
+## License
+
+MIT

minimax_code_sdk-0.1.0b1.dist-info/RECORD

@@ -0,0 +1,15 @@
+minimax_code/__init__.py,sha256=Ur2NagxwfLigJUBOPRlJfsyjmxrlanCFtYJFkUJ9H_Q,1275
+minimax_code/_args.py,sha256=23WFCz0y3SRqisEChPPsCWvAtl_U3Jzc1kGCcTQh1SE,3251
+minimax_code/_cli.py,sha256=nfqda8v_3EHQ2hov3zfBRCE9JHtmV0uTjz04Xxeik9o,3143
+minimax_code/_items.py,sha256=rFtcUV2ZstKYiY1x6R0x5dpqflZZDqngMBRdr7UHLgE,2423
+minimax_code/_protocol.py,sha256=rhHZdoTTPDI3QFme5Jg1PoWa15GhI8pvC6QANj7DFP8,2138
+minimax_code/client.py,sha256=2O8Tnah8xBqNe1agi1Xt_3t3CcoIDpH1Kif-pjwUOkQ,2539
+minimax_code/errors.py,sha256=V8M3Y-WL_3z6mT-EEt3CsQ9uE1KehVI0hUGtw89NFO0,4484
+minimax_code/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+minimax_code/sync.py,sha256=xupP3Wqy8TNIsRbZVKl-11nzc6TpEzVz6ry68D7_8K0,2366
+minimax_code/thread.py,sha256=53TbJdbyRmjzUnOvoyZ2G6FTw2dOUuJEPzrIOO_Aq5s,12162
+minimax_code/types.py,sha256=LXjJGyT-_W_HC2St34-vPY8d2CRZV9FBOtPj1_fB4PI,5363
+minimax_code_sdk-0.1.0b1.dist-info/METADATA,sha256=CtVpGo46KC5tfgzF_c2yNc8-7ppgpW036k5OPZtDMwg,4584
+minimax_code_sdk-0.1.0b1.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+minimax_code_sdk-0.1.0b1.dist-info/licenses/LICENSE,sha256=KLtcKUh0L5-NJ-2EiChE0J3_B8td9k8gcph16FgqGOo,1069
+minimax_code_sdk-0.1.0b1.dist-info/RECORD,,

minimax_code_sdk-0.1.0b1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

minimax_code_sdk-0.1.0b1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 MiniMax Code
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.