kimi-agent-module-api 1.1.0__tar.gz → 1.3.0__tar.gz

{kimi_agent_module_api-1.1.0/src/kimi_agent_module_api.egg-info → kimi_agent_module_api-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kimi-agent-module-api
-Version: 1.1.0
+Version: 1.3.0
 Summary: Stable contracts for community-built assistant modules
 Author: Webhead
 License-Expression: MIT
@@ -54,3 +54,20 @@ Guild-scoped live command replacement was added in 1.1. Modules using
 `InteractionRouter.replace_guild_commands()` should depend on
 `kimi-agent-module-api>=1.1,<2` and require the host capability
 `discord.guild_commands.v1`.
+
+Version 1.2 adds typed modal forms and a narrow Components V2 layout model. Once a response uses
+that layout model, Discord requires every later edit of the same message to remain a layout.
+Modules using them should depend on `kimi-agent-module-api>=1.2,<2` and require
+`discord.modals.v1` and/or `discord.components_v2.v1`.
+
+Version 1.3 adds cached author classification to message-deletion events:
+`MessageDeleteEvent.author_is_bot` and `MessageBulkDeleteEvent.bot_message_ids`.
+The values remain unknown for messages that were absent from Discord's cache.
+
+## Testing the SDK
+
+From this package directory, run its tests without installing the Kimi application:
+
+```console
+uv run --isolated --group test python -m pytest -q
+```

{kimi_agent_module_api-1.1.0 → kimi_agent_module_api-1.3.0}/README.md

@@ -37,3 +37,20 @@ Guild-scoped live command replacement was added in 1.1. Modules using
 `InteractionRouter.replace_guild_commands()` should depend on
 `kimi-agent-module-api>=1.1,<2` and require the host capability
 `discord.guild_commands.v1`.
+
+Version 1.2 adds typed modal forms and a narrow Components V2 layout model. Once a response uses
+that layout model, Discord requires every later edit of the same message to remain a layout.
+Modules using them should depend on `kimi-agent-module-api>=1.2,<2` and require
+`discord.modals.v1` and/or `discord.components_v2.v1`.
+
+Version 1.3 adds cached author classification to message-deletion events:
+`MessageDeleteEvent.author_is_bot` and `MessageBulkDeleteEvent.bot_message_ids`.
+The values remain unknown for messages that were absent from Discord's cache.
+
+## Testing the SDK
+
+From this package directory, run its tests without installing the Kimi application:
+
+```console
+uv run --isolated --group test python -m pytest -q
+```

{kimi_agent_module_api-1.1.0 → kimi_agent_module_api-1.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kimi-agent-module-api"
-version = "1.1.0"
+version = "1.3.0"
 description = "Stable contracts for community-built assistant modules"
 requires-python = ">=3.14"
 authors = [{ name = "Webhead" }]
@@ -18,6 +18,9 @@ Repository = "https://github.com/webhead2oo9/kimi-agent"
 # kimi_agent_module_api.testing.MemoryStorage runs real SQL in unit tests.
 testing = ["aiosqlite"]
 
+[dependency-groups]
+test = ["aiosqlite", "pytest", "pytest-asyncio"]
+
 [build-system]
 requires = ["setuptools>=84"]
 build-backend = "setuptools.build_meta"
@@ -27,3 +30,7 @@ where = ["src"]
 
 [tool.setuptools.package-data]
 kimi_agent_module_api = ["py.typed"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_default_fixture_loop_scope = "function"

{kimi_agent_module_api-1.1.0 → kimi_agent_module_api-1.3.0}/src/kimi_agent_module_api/__init__.py

@@ -20,9 +20,17 @@ from kimi_agent_module_api.contracts import (
     HealthReporter,
     InviteSnapshot,
     InteractionRouter,
+    LayoutGallery,
+    LayoutItem,
+    LayoutSection,
+    LayoutSeparator,
+    LayoutSeparatorSpacing,
+    LayoutText,
+    ModalSpec,
     ModuleHttp,
     ModulePermissions,
     ModuleStorage,
+    OutgoingLayout,
     ScopedModuleMigration,
     ProposalActor,
     ProposalError,
@@ -34,6 +42,8 @@ from kimi_agent_module_api.contracts import (
     ServiceRegistry,
     ServiceRequirement,
     TrustLookup,
+    TextInputSpec,
+    TextInputStyle,
 )
 from kimi_agent_module_api.settings import ModuleSetting, ModuleSettingsDefinition
 from kimi_agent_module_api.tools import (
@@ -151,6 +161,13 @@ __all__ = [
     "ConfigSnapshot",
     "GuildSettingsSchema",
     "InviteSnapshot",
+    "LayoutGallery",
+    "LayoutItem",
+    "LayoutSection",
+    "LayoutSeparator",
+    "LayoutSeparatorSpacing",
+    "LayoutText",
+    "ModalSpec",
     "ModuleCapabilities",
     "ModuleLoadContext",
     "ModulePermissions",
@@ -161,6 +178,7 @@ __all__ = [
     "ModuleToolContext",
     "ModuleToolHandler",
     "ModuleToolRegistry",
+    "OutgoingLayout",
     "ProposalActor",
     "ProposalError",
     "ProposalRef",
@@ -170,6 +188,8 @@ __all__ = [
     "ScopedModuleMigration",
     "ServiceDeclaration",
     "ServiceRequirement",
+    "TextInputSpec",
+    "TextInputStyle",
     "TrustTier",
     "render_guild_settings",
 ]

{kimi_agent_module_api-1.1.0 → kimi_agent_module_api-1.3.0}/src/kimi_agent_module_api/contracts.py

@@ -12,6 +12,7 @@ owner manifest and enforced through the ports below; they are not a sandbox.
 from __future__ import annotations
 
 import json
+import keyword
 import math
 import re
 from collections.abc import AsyncIterator, Awaitable, Callable, Mapping, Sequence
@@ -326,6 +327,13 @@ CORE_TOPIC_PREFIX = "discord"
 _CORE_RESERVED_MODULE_NAMES = frozenset({CORE_TOPIC_PREFIX, "proposals"})
 CUSTOM_ID_PREFIX = "m"
 CUSTOM_ID_MAX_LENGTH = 100
+# A modal ID also carries a fixed-width per-open suffix so two people opening the
+# same form do not share one entry in the host's modal table. That suffix is not
+# the module's to spend, so a modal's declared ID has a smaller budget than a
+# button's. Fixed width on purpose: a variable one would shrink the budget as the
+# host ran, letting a modal open successfully and then fail later.
+MODAL_NONCE_CHARS = 8
+MODAL_CUSTOM_ID_MAX_LENGTH = CUSTOM_ID_MAX_LENGTH - 1 - MODAL_NONCE_CHARS
 
 
 def table_prefix(module_name: str) -> str:
@@ -819,6 +827,82 @@ class OutgoingEmbed:
     timestamp: bool = False
 
 
+@dataclass(frozen=True, slots=True)
+class LayoutText:
+    content: str
+
+
+type LayoutSeparatorSpacing = Literal["small", "large"]
+
+
+@dataclass(frozen=True, slots=True)
+class LayoutSeparator:
+    visible: bool = True
+    spacing: LayoutSeparatorSpacing = "small"
+
+
+@dataclass(frozen=True, slots=True)
+class LayoutGallery:
+    urls: tuple[str, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class LayoutSection:
+    texts: tuple[str, ...]
+    thumbnail_url: str
+
+
+type LayoutItem = LayoutText | LayoutSeparator | LayoutGallery | LayoutSection
+
+
+@dataclass(frozen=True, slots=True)
+class OutgoingLayout:
+    """One Components V2 container, optionally followed by interactive controls."""
+
+    items: tuple[LayoutItem, ...]
+    accent_color: int | None = None
+
+
+def validate_outgoing_layout(layout: OutgoingLayout) -> None:
+    """Validate the Discord hard limits represented by ``OutgoingLayout``."""
+    if not 1 <= len(layout.items) <= 40:
+        raise ModuleContractError("a layout must contain between one and 40 items")
+    if layout.accent_color is not None and (
+        isinstance(layout.accent_color, bool) or not 0 <= layout.accent_color <= 0xFFFFFF
+    ):
+        raise ModuleContractError("layout accent_color must be between 0 and 0xFFFFFF")
+
+    def validate_text(text: Any, label: str) -> None:
+        if not isinstance(text, str) or not 1 <= len(text) <= 4_000:
+            raise ModuleContractError(f"{label} must contain between one and 4000 characters")
+
+    text_length = 0
+    for item in layout.items:
+        if isinstance(item, LayoutText):
+            validate_text(item.content, "layout text")
+            text_length += len(item.content)
+        elif isinstance(item, LayoutSeparator):
+            if item.spacing not in ("small", "large"):
+                raise ModuleContractError(f"invalid layout separator spacing {item.spacing!r}")
+        elif isinstance(item, LayoutGallery):
+            if not 1 <= len(item.urls) <= 10:
+                raise ModuleContractError("a layout gallery must contain between one and 10 URLs")
+            if any(not isinstance(url, str) or not url for url in item.urls):
+                raise ModuleContractError("layout gallery URLs must be non-empty strings")
+        elif isinstance(item, LayoutSection):
+            if not 1 <= len(item.texts) <= 3:
+                raise ModuleContractError("a layout section must contain between one and 3 texts")
+            for text in item.texts:
+                validate_text(text, "layout section text")
+                text_length += len(text)
+            if not isinstance(item.thumbnail_url, str) or not item.thumbnail_url:
+                raise ModuleContractError("a layout section thumbnail URL must be non-empty")
+        else:
+            raise ModuleContractError(f"unsupported layout item {item!r}")
+    if text_length > 4_000:
+        raise ModuleContractError("layout text cannot exceed 4000 characters in total")
+
+
 class DiscordActions(Protocol):
     """Declared Discord operations on stable IDs.
 
@@ -911,6 +995,7 @@ class TrustLookup(Protocol):
 
 
 type CommandOptionKind = Literal["string", "integer", "boolean", "user", "channel", "role"]
+_OPTION_KINDS = frozenset({"string", "integer", "boolean", "user", "channel", "role"})
 
 
 @dataclass(frozen=True, slots=True)
@@ -957,6 +1042,9 @@ class ModuleInteraction(Protocol):
     @property
     def values(self) -> tuple[str, ...]: ...
 
+    @property
+    def text_values(self) -> Mapping[str, str]: ...
+
     @property
     def message(self) -> MessageRef | None:
         """The message a button or select lives on; ``None`` for slash commands."""
@@ -967,17 +1055,21 @@ class ModuleInteraction(Protocol):
         content: str | None = None,
         *,
         embed: OutgoingEmbed | None = None,
+        layout: OutgoingLayout | None = None,
         ephemeral: bool = False,
         components: Sequence[Any] = (),
     ) -> None: ...
 
     async def defer(self, *, ephemeral: bool = False) -> None: ...
 
+    async def show_modal(self, modal: ModalSpec) -> None: ...
+
     async def edit_original(
         self,
         content: str | None = None,
         *,
         embed: OutgoingEmbed | None = None,
+        layout: OutgoingLayout | None = None,
         components: Sequence[Any] = (),
     ) -> None: ...
 
@@ -1013,11 +1105,316 @@ class SelectSpec:
     max_values: int = 1
 
 
+def validate_layout_components(
+    components: Sequence[Any], *, layout: OutgoingLayout | None = None
+) -> None:
+    """Validate control rows and the full Components V2 descendant limit."""
+    rows = 0
+    buttons_in_row = 0
+    for component in components:
+        if isinstance(component, ButtonSpec):
+            if buttons_in_row == 0:
+                rows += 1
+            buttons_in_row = (buttons_in_row + 1) % 5
+        elif isinstance(component, SelectSpec):
+            buttons_in_row = 0
+            rows += 1
+        else:
+            raise ModuleContractError(f"unsupported component {component!r}")
+    if rows > 5:
+        raise ModuleContractError("layout controls cannot require more than five action rows")
+    if layout is not None:
+        descendants = 1 + rows + len(components)
+        for item in layout.items:
+            descendants += len(item.texts) + 2 if isinstance(item, LayoutSection) else 1
+        if descendants > 40:
+            raise ModuleContractError("a layout cannot exceed 40 components in total")
+
+
+type TextInputStyle = Literal["short", "paragraph"]
+
+
+@dataclass(frozen=True, slots=True)
+class TextInputSpec:
+    key: str
+    label: str
+    style: TextInputStyle = "short"
+    default: str | None = None
+    placeholder: str | None = None
+    required: bool = True
+    min_length: int | None = None
+    max_length: int | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class ModalSpec:
+    """A modal whose submit handler is registered under ``key``."""
+
+    key: str
+    title: str
+    inputs: tuple[TextInputSpec, ...]
+    parts: tuple[str, ...] = ()
+
+
+_OPTIONS_WITH_CHOICES = frozenset({"string", "integer"})
+# Keep command and group name validation in the SDK so the public fakes reject
+# the same payloads discord.py rejects while constructing the live tree.
+_COMMAND_NAME_RE = re.compile(
+    r"^[-_\w\u0e31-\u0e3a\u0e47-\u0e4e\u0900-\u0903\u093a\u093b\u093c"
+    r"\u093e\u093f\u0940-\u094f\u0955\u0956\u0957\u0962\u0963]{1,32}$"
+)
+_BUTTON_STYLES = frozenset({"primary", "secondary", "success", "danger"})
+_DISCORD_INTEGER_MAX = (1 << 53) - 1
+_DISCORD_INTEGER_MIN = -_DISCORD_INTEGER_MAX
+
+
+def validate_command_spec(spec: CommandSpec) -> None:
+    """Validate the Discord limits a command payload must satisfy.
+
+    A whole ``tree.sync()`` is one bulk PUT, so a single malformed command
+    rejects every command in that scope. Discord.py checks command and group
+    *names* itself and reorders required options ahead of optional ones; these
+    are the limits nothing else enforces before the payload reaches Discord.
+    """
+
+    for label, name in (("command", spec.name), ("command group", spec.group)):
+        if name is None:
+            continue
+        if (
+            not isinstance(name, str)
+            or _COMMAND_NAME_RE.fullmatch(name) is None
+            or name.lower() != name
+        ):
+            raise ModuleContractError(f"invalid {label} name {name!r}")
+    if not isinstance(spec.description, str) or not 1 <= len(spec.description) <= 100:
+        raise ModuleContractError("a command description must contain 1 to 100 characters")
+    if spec.group is not None and (
+        not isinstance(spec.group_description, str) or len(spec.group_description) > 100
+    ):
+        raise ModuleContractError("a command group description cannot exceed 100 characters")
+    if len(spec.options) > 25:
+        raise ModuleContractError("a command cannot declare more than 25 options")
+
+    names: set[str] = set()
+    for option in spec.options:
+        # Discord applies the slash-command name grammar to option names, while
+        # the host also builds each option into a Python parameter. Enforce the
+        # intersection here: this keeps valid leading underscores and lowercase
+        # Unicode identifiers while rejecting Discord-only names such as ``a-b``.
+        if (
+            not isinstance(option.name, str)
+            or _COMMAND_NAME_RE.fullmatch(option.name) is None
+            or option.name.lower() != option.name
+            or not option.name.isidentifier()
+            or keyword.iskeyword(option.name)
+        ):
+            raise ModuleContractError(f"invalid command option name {option.name!r}")
+        if option.name in names:
+            raise ModuleContractError("command option names must be unique")
+        names.add(option.name)
+        if option.kind not in _OPTION_KINDS:
+            raise ModuleContractError(f"unsupported command option kind {option.kind!r}")
+        if not isinstance(option.description, str) or not 1 <= len(option.description) <= 100:
+            raise ModuleContractError(
+                f"the description for option {option.name!r} must contain 1 to 100 characters"
+            )
+        if option.choices and option.autocomplete:
+            # Discord rejects a payload carrying both, and discord.py emits both.
+            raise ModuleContractError(
+                f"option {option.name!r} cannot use choices and autocomplete together"
+            )
+        if (option.choices or option.autocomplete) and option.kind not in _OPTIONS_WITH_CHOICES:
+            raise ModuleContractError(
+                f"option {option.name!r} cannot use choices or autocomplete on a "
+                f"{option.kind} option"
+            )
+        if len(option.choices) > 25:
+            raise ModuleContractError(f"option {option.name!r} cannot declare more than 25 choices")
+        values: set[str | int] = set()
+        for name, value in option.choices:
+            if not isinstance(name, str) or not 1 <= len(name) <= 100:
+                raise ModuleContractError(f"invalid choice name {name!r} on option {option.name!r}")
+            if isinstance(value, bool) or not isinstance(value, str | int):
+                raise ModuleContractError(
+                    f"invalid choice value {value!r} on option {option.name!r}"
+                )
+            # A choice whose value type disagrees with its option is a 400 on the
+            # whole payload, and nothing downstream cross-checks the two.
+            if not isinstance(value, str if option.kind == "string" else int):
+                raise ModuleContractError(
+                    f"choice values on {option.kind} option {option.name!r} must be "
+                    f"{'strings' if option.kind == 'string' else 'integers'}"
+                )
+            if (
+                option.kind == "integer"
+                and isinstance(value, int)
+                and not _DISCORD_INTEGER_MIN <= value <= _DISCORD_INTEGER_MAX
+            ):
+                raise ModuleContractError(
+                    f"an integer choice value on option {option.name!r} must be between "
+                    f"{_DISCORD_INTEGER_MIN} and {_DISCORD_INTEGER_MAX}"
+                )
+            if isinstance(value, str) and not 1 <= len(value) <= 100:
+                raise ModuleContractError(
+                    f"a choice value on option {option.name!r} must contain 1 to 100 characters"
+                )
+            if value in values:
+                raise ModuleContractError(f"choice values on option {option.name!r} must be unique")
+            values.add(value)
+        for bound in (option.min_value, option.max_value):
+            if bound is None:
+                continue
+            if isinstance(bound, bool) or not isinstance(bound, int):
+                raise ModuleContractError(f"option {option.name!r} bounds must be integers")
+            if option.kind != "integer":
+                # Only integer options carry the bounds through to Discord, so a
+                # bound anywhere else would be silently dropped.
+                raise ModuleContractError(
+                    f"option {option.name!r} cannot set min_value or max_value on a "
+                    f"{option.kind} option"
+                )
+            if not _DISCORD_INTEGER_MIN <= bound <= _DISCORD_INTEGER_MAX:
+                raise ModuleContractError(
+                    f"option {option.name!r} bounds must be between "
+                    f"{_DISCORD_INTEGER_MIN} and {_DISCORD_INTEGER_MAX}"
+                )
+        if (
+            option.min_value is not None
+            and option.max_value is not None
+            and option.min_value > option.max_value
+        ):
+            raise ModuleContractError(f"option {option.name!r} min_value cannot exceed max_value")
+
+
+def validate_button_spec(button: ButtonSpec) -> None:
+    """Validate Discord's hard button limits."""
+
+    if not isinstance(button.key, str) or not _TOPIC_SEGMENT_RE.fullmatch(button.key):
+        raise ModuleContractError(f"invalid button key {button.key!r}")
+    if any(not isinstance(part, str) or ":" in part for part in button.parts):
+        raise ModuleContractError("button custom_id parts must be strings without ':'")
+    if not isinstance(button.label, str) or len(button.label) > 80:
+        raise ModuleContractError("a button label cannot exceed 80 characters")
+    if button.style not in _BUTTON_STYLES:
+        raise ModuleContractError(f"invalid button style {button.style!r}")
+    if button.emoji is not None and (not isinstance(button.emoji, str) or not button.emoji):
+        raise ModuleContractError("a button emoji must be a non-empty string")
+    if not button.label and button.emoji is None:
+        raise ModuleContractError("a button must provide a label or emoji")
+
+
+def validate_component_spec(component: Any) -> None:
+    """Validate one interactive component, whichever kind it is."""
+
+    if isinstance(component, ButtonSpec):
+        validate_button_spec(component)
+    elif isinstance(component, SelectSpec):
+        validate_select_spec(component)
+    else:
+        raise ModuleContractError(f"unsupported component {component!r}")
+
+
+def validate_select_spec(select: SelectSpec) -> None:
+    """Validate Discord's hard select-menu limits."""
+
+    if not isinstance(select.key, str) or not _TOPIC_SEGMENT_RE.fullmatch(select.key):
+        raise ModuleContractError(f"invalid select key {select.key!r}")
+    if any(not isinstance(part, str) or ":" in part for part in select.parts):
+        raise ModuleContractError("select custom_id parts must be strings without ':'")
+    if select.placeholder is not None and (
+        not isinstance(select.placeholder, str) or len(select.placeholder) > 150
+    ):
+        raise ModuleContractError("a select placeholder cannot exceed 150 characters")
+    if not 1 <= len(select.options) <= 25:
+        raise ModuleContractError("a select must contain between one and 25 options")
+
+    values: set[str] = set()
+    for label, value, description in select.options:
+        if not isinstance(label, str) or not 1 <= len(label) <= 100:
+            raise ModuleContractError("a select option label must contain 1 to 100 characters")
+        if not isinstance(value, str) or not 1 <= len(value) <= 100:
+            raise ModuleContractError("a select option value must contain 1 to 100 characters")
+        if value in values:
+            raise ModuleContractError("select option values must be unique")
+        values.add(value)
+        if description is not None and (
+            not isinstance(description, str) or not 1 <= len(description) <= 100
+        ):
+            raise ModuleContractError(
+                "a select option description must contain 1 to 100 characters"
+            )
+
+    for name, bound, low in (
+        ("min_values", select.min_values, 0),
+        ("max_values", select.max_values, 1),
+    ):
+        if isinstance(bound, bool) or not isinstance(bound, int) or not low <= bound <= 25:
+            raise ModuleContractError(f"select {name} must be between {low} and 25")
+    if select.min_values > select.max_values:
+        raise ModuleContractError("select min_values cannot exceed max_values")
+    # max_values may exceed the option count (Discord clamps it), but a
+    # minimum above the count can never be satisfied, so the select is dead.
+    if select.min_values > len(select.options):
+        raise ModuleContractError("select min_values cannot exceed the number of options")
+
+
+def validate_modal_spec(modal: ModalSpec) -> None:
+    """Validate Discord's hard modal and text-input limits."""
+    if not isinstance(modal.key, str) or not _TOPIC_SEGMENT_RE.fullmatch(modal.key):
+        raise ModuleContractError(f"invalid modal key {modal.key!r}")
+    if any(not isinstance(part, str) or ":" in part for part in modal.parts):
+        raise ModuleContractError("modal custom_id parts must be strings without ':'")
+    if not isinstance(modal.title, str) or not 1 <= len(modal.title) <= 45:
+        raise ModuleContractError("a modal title must contain between one and 45 characters")
+    if not 1 <= len(modal.inputs) <= 5:
+        raise ModuleContractError("a modal must contain between one and five text inputs")
+
+    keys: set[str] = set()
+    for input_spec in modal.inputs:
+        if not isinstance(input_spec.key, str) or not _TOPIC_SEGMENT_RE.fullmatch(input_spec.key):
+            raise ModuleContractError(f"invalid modal text input key {input_spec.key!r}")
+        if input_spec.key in keys:
+            raise ModuleContractError("modal text input keys must be unique")
+        keys.add(input_spec.key)
+        if not isinstance(input_spec.label, str) or not 1 <= len(input_spec.label) <= 45:
+            raise ModuleContractError(
+                "a modal text input label must contain between one and 45 characters"
+            )
+        if input_spec.style not in ("short", "paragraph"):
+            raise ModuleContractError(f"invalid modal text input style {input_spec.style!r}")
+        if input_spec.placeholder is not None and (
+            not isinstance(input_spec.placeholder, str) or len(input_spec.placeholder) > 100
+        ):
+            raise ModuleContractError("a modal text input placeholder cannot exceed 100 characters")
+        if input_spec.default is not None and (
+            not isinstance(input_spec.default, str) or len(input_spec.default) > 4_000
+        ):
+            raise ModuleContractError("a modal text input default cannot exceed 4000 characters")
+        if input_spec.min_length is not None and (
+            isinstance(input_spec.min_length, bool)
+            or not isinstance(input_spec.min_length, int)
+            or not 0 <= input_spec.min_length <= 4_000
+        ):
+            raise ModuleContractError("modal text input min_length must be between 0 and 4000")
+        if input_spec.max_length is not None and (
+            isinstance(input_spec.max_length, bool)
+            or not isinstance(input_spec.max_length, int)
+            or not 1 <= input_spec.max_length <= 4_000
+        ):
+            raise ModuleContractError("modal text input max_length must be between 1 and 4000")
+        if (
+            input_spec.min_length is not None
+            and input_spec.max_length is not None
+            and input_spec.min_length > input_spec.max_length
+        ):
+            raise ModuleContractError("modal text input min_length cannot exceed max_length")
+
+
 type CommandHandler = Callable[[ModuleInteraction], Awaitable[None]]
 type AutocompleteHandler = Callable[
     [ModuleInteraction, str, str], Awaitable[Sequence[tuple[str, str | int]]]
 ]
-type ComponentKind = Literal["button", "select"]
+type ComponentKind = Literal["button", "select", "modal"]
 
 
 @dataclass(frozen=True, slots=True)

{kimi_agent_module_api-1.1.0 → kimi_agent_module_api-1.3.0}/src/kimi_agent_module_api/events.py

@@ -69,11 +69,13 @@ class MessageDeleteEvent:
     author_id: int | None
     cached_content: str | None
     cached_attachments: tuple[AttachmentSnapshot, ...]
+    author_is_bot: bool | None = None
 
 
 @dataclass(frozen=True, slots=True)
 class MessageBulkDeleteEvent:
     refs: tuple[MessageRef, ...]
+    bot_message_ids: tuple[int, ...] = ()
 
 
 @dataclass(frozen=True, slots=True)