yee88 0.3.0__py3-none-any.whl

yee88/telegram/commands/agent.py

@@ -0,0 +1,196 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ...context import RunContext
+from ...directives import DirectiveError
+from ..chat_prefs import ChatPrefsStore
+from ..engine_defaults import resolve_engine_for_message
+from ..engine_overrides import resolve_override_value
+from ..files import split_command_args
+from ..topic_state import TopicStateStore
+from ..topics import _topic_key
+from ..types import TelegramIncomingMessage
+from .reply import make_reply
+
+if TYPE_CHECKING:
+    from ..bridge import TelegramBridgeConfig
+
+AGENT_USAGE = "usage: `/agent`, `/agent set <engine>`, or `/agent clear`"
+
+
+async def _check_agent_permissions(
+    cfg: TelegramBridgeConfig, msg: TelegramIncomingMessage
+) -> bool:
+    reply = make_reply(cfg, msg)
+    sender_id = msg.sender_id
+    if sender_id is None:
+        await reply(text="cannot verify sender for engine defaults.")
+        return False
+    if msg.is_private:
+        return True
+    member = await cfg.bot.get_chat_member(msg.chat_id, sender_id)
+    if member is None:
+        await reply(text="failed to verify engine permissions.")
+        return False
+    if member.status in {"creator", "administrator"}:
+        return True
+    await reply(text="changing default engines is restricted to group admins.")
+    return False
+
+
+async def _handle_agent_command(
+    cfg: TelegramBridgeConfig,
+    msg: TelegramIncomingMessage,
+    args_text: str,
+    ambient_context: RunContext | None,
+    topic_store: TopicStateStore | None,
+    chat_prefs: ChatPrefsStore | None,
+    *,
+    resolved_scope: str | None = None,
+    scope_chat_ids: frozenset[int] | None = None,
+) -> None:
+    reply = make_reply(cfg, msg)
+    tkey = (
+        _topic_key(msg, cfg, scope_chat_ids=scope_chat_ids)
+        if topic_store is not None
+        else None
+    )
+    tokens = split_command_args(args_text)
+    action = tokens[0].lower() if tokens else "show"
+
+    if action in {"show", ""}:
+        try:
+            resolved = cfg.runtime.resolve_message(
+                text="",
+                reply_text=msg.reply_to_text,
+                ambient_context=ambient_context,
+                chat_id=msg.chat_id,
+            )
+        except DirectiveError as exc:
+            await reply(text=f"error:\n{exc}")
+            return
+        selection = await resolve_engine_for_message(
+            runtime=cfg.runtime,
+            context=resolved.context,
+            explicit_engine=None,
+            chat_id=msg.chat_id,
+            topic_key=tkey,
+            topic_store=topic_store,
+            chat_prefs=chat_prefs,
+        )
+        source_labels = {
+            "directive": "directive",
+            "topic_default": "topic default",
+            "chat_default": "chat default",
+            "project_default": "project default",
+            "global_default": "global default",
+        }
+        agent_line = f"engine: {selection.engine} ({source_labels[selection.source]})"
+        topic_override = None
+        if tkey is not None and topic_store is not None:
+            topic_override = await topic_store.get_engine_override(
+                tkey[0], tkey[1], selection.engine
+            )
+        chat_override = None
+        if chat_prefs is not None:
+            chat_override = await chat_prefs.get_engine_override(
+                msg.chat_id, selection.engine
+            )
+        override_labels = {
+            "topic_override": "topic override",
+            "chat_default": "chat default",
+            "default": "no override",
+        }
+        model_resolution = resolve_override_value(
+            topic_override=topic_override,
+            chat_override=chat_override,
+            field="model",
+        )
+        reasoning_resolution = resolve_override_value(
+            topic_override=topic_override,
+            chat_override=chat_override,
+            field="reasoning",
+        )
+        model_value = model_resolution.value or "default"
+        model_line = (
+            f"model: {model_value} ({override_labels[model_resolution.source]})"
+        )
+        reasoning_value = reasoning_resolution.value or "default"
+        reasoning_line = (
+            "reasoning: "
+            f"{reasoning_value} ({override_labels[reasoning_resolution.source]})"
+        )
+        topic_default = selection.topic_default or "none"
+        if tkey is None:
+            topic_default = "none"
+        if chat_prefs is None:
+            chat_default = "unavailable"
+        else:
+            chat_default = selection.chat_default or "none"
+        project_default = (
+            selection.project_default
+            if selection.project_default is not None
+            else "none"
+        )
+        defaults_line = (
+            "defaults: "
+            f"topic: {topic_default}, "
+            f"chat: {chat_default}, "
+            f"project: {project_default}, "
+            f"global: {cfg.runtime.default_engine}"
+        )
+        available = ", ".join(cfg.runtime.engine_ids)
+        available_line = f"available: {available}"
+        await reply(
+            text="\n\n".join(
+                [agent_line, model_line, reasoning_line, defaults_line, available_line]
+            )
+        )
+        return
+
+    if action == "set":
+        if len(tokens) < 2:
+            await reply(text=AGENT_USAGE)
+            return
+        if not await _check_agent_permissions(cfg, msg):
+            return
+        engine = tokens[1].strip().lower()
+        if engine not in cfg.runtime.engine_ids:
+            available = ", ".join(cfg.runtime.engine_ids)
+            await reply(
+                text=f"unknown engine `{engine}`.\navailable engines: `{available}`",
+            )
+            return
+        if tkey is not None:
+            if topic_store is None:
+                await reply(text="topic defaults are unavailable.")
+                return
+            await topic_store.set_default_engine(tkey[0], tkey[1], engine)
+            await reply(text=f"topic default engine set to `{engine}`")
+            return
+        if chat_prefs is None:
+            await reply(text="chat defaults are unavailable (no config path).")
+            return
+        await chat_prefs.set_default_engine(msg.chat_id, engine)
+        await reply(text=f"chat default engine set to `{engine}`")
+        return
+
+    if action == "clear":
+        if not await _check_agent_permissions(cfg, msg):
+            return
+        if tkey is not None:
+            if topic_store is None:
+                await reply(text="topic defaults are unavailable.")
+                return
+            await topic_store.clear_default_engine(tkey[0], tkey[1])
+            await reply(text="topic default engine cleared.")
+            return
+        if chat_prefs is None:
+            await reply(text="chat defaults are unavailable (no config path).")
+            return
+        await chat_prefs.clear_default_engine(msg.chat_id)
+        await reply(text="chat default engine cleared.")
+        return
+
+    await reply(text=AGENT_USAGE)

yee88/telegram/commands/cancel.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ...logging import get_logger
+from ...progress import ProgressTracker
+from ...runner_bridge import RunningTasks
+from ...scheduler import ThreadJob, ThreadScheduler
+from ...transport import MessageRef
+from ..types import TelegramCallbackQuery, TelegramIncomingMessage
+from .reply import make_reply
+
+if TYPE_CHECKING:
+    from ..bridge import TelegramBridgeConfig
+
+logger = get_logger(__name__)
+
+
+async def handle_cancel(
+    cfg: TelegramBridgeConfig,
+    msg: TelegramIncomingMessage,
+    running_tasks: RunningTasks,
+    scheduler: ThreadScheduler | None = None,
+) -> None:
+    reply = make_reply(cfg, msg)
+    chat_id = msg.chat_id
+    reply_id = msg.reply_to_message_id
+
+    if reply_id is None:
+        if msg.reply_to_text:
+            await reply(text="nothing is currently running for that message.")
+            return
+        await reply(text="reply to the progress message to cancel.")
+        return
+
+    progress_ref = MessageRef(channel_id=chat_id, message_id=reply_id)
+    running_task = running_tasks.get(progress_ref)
+    if running_task is None:
+        if scheduler is not None:
+            job = await scheduler.cancel_queued(chat_id, reply_id)
+            if job is not None:
+                logger.info(
+                    "cancel.queued",
+                    chat_id=chat_id,
+                    progress_message_id=reply_id,
+                    resume=job.resume_token.value,
+                )
+                await _edit_cancelled_message(cfg, progress_ref, job)
+                return
+        await reply(text="nothing is currently running for that message.")
+        return
+
+    logger.info(
+        "cancel.requested",
+        chat_id=chat_id,
+        progress_message_id=reply_id,
+    )
+    running_task.cancel_requested.set()
+
+
+async def handle_callback_cancel(
+    cfg: TelegramBridgeConfig,
+    query: TelegramCallbackQuery,
+    running_tasks: RunningTasks,
+    scheduler: ThreadScheduler | None = None,
+) -> None:
+    progress_ref = MessageRef(channel_id=query.chat_id, message_id=query.message_id)
+    running_task = running_tasks.get(progress_ref)
+    if running_task is None:
+        if scheduler is not None:
+            job = await scheduler.cancel_queued(query.chat_id, query.message_id)
+            if job is not None:
+                logger.info(
+                    "cancel.queued",
+                    chat_id=query.chat_id,
+                    progress_message_id=query.message_id,
+                    resume=job.resume_token.value,
+                )
+                await _edit_cancelled_message(cfg, progress_ref, job)
+                await cfg.bot.answer_callback_query(
+                    callback_query_id=query.callback_query_id,
+                    text="dropped from queue.",
+                )
+                return
+        await cfg.bot.answer_callback_query(
+            callback_query_id=query.callback_query_id,
+            text="nothing is currently running for that message.",
+        )
+        return
+    logger.info(
+        "cancel.requested",
+        chat_id=query.chat_id,
+        progress_message_id=query.message_id,
+    )
+    running_task.cancel_requested.set()
+    await cfg.bot.answer_callback_query(
+        callback_query_id=query.callback_query_id,
+        text="cancelling...",
+    )
+
+
+async def _edit_cancelled_message(
+    cfg: TelegramBridgeConfig,
+    progress_ref: MessageRef,
+    job: ThreadJob,
+) -> None:
+    tracker = ProgressTracker(engine=job.resume_token.engine)
+    tracker.set_resume(job.resume_token)
+    context_line = cfg.runtime.format_context_line(job.context)
+    state = tracker.snapshot(context_line=context_line)
+    message = cfg.exec_cfg.presenter.render_progress(
+        state,
+        elapsed_s=0.0,
+        label="`cancelled`",
+    )
+    await cfg.exec_cfg.transport.edit(ref=progress_ref, message=message)

yee88/telegram/commands/dispatch.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from typing import TYPE_CHECKING
+
+import anyio
+
+from ...commands import CommandContext, get_command
+from ...config import ConfigError
+from ...logging import get_logger
+from ...model import EngineId, ResumeToken
+from ...runners.run_options import EngineRunOptions
+from ...runner_bridge import RunningTasks
+from ...scheduler import ThreadScheduler
+from ...transport import MessageRef
+from ..files import split_command_args
+from ..types import TelegramIncomingMessage
+from .executor import _TelegramCommandExecutor
+
+if TYPE_CHECKING:
+    from ..bridge import TelegramBridgeConfig
+
+logger = get_logger(__name__)
+
+
+async def _dispatch_command(
+    cfg: TelegramBridgeConfig,
+    msg: TelegramIncomingMessage,
+    text: str,
+    command_id: str,
+    args_text: str,
+    running_tasks: RunningTasks,
+    scheduler: ThreadScheduler,
+    on_thread_known: Callable[[ResumeToken, anyio.Event], Awaitable[None]] | None,
+    stateful_mode: bool,
+    default_engine_override: EngineId | None,
+    engine_overrides_resolver: Callable[[EngineId], Awaitable[EngineRunOptions | None]]
+    | None,
+) -> None:
+    allowlist = cfg.runtime.allowlist
+    chat_id = msg.chat_id
+    user_msg_id = msg.message_id
+    reply_ref = (
+        MessageRef(
+            channel_id=chat_id,
+            message_id=msg.reply_to_message_id,
+            thread_id=msg.thread_id,
+        )
+        if msg.reply_to_message_id is not None
+        else None
+    )
+    executor = _TelegramCommandExecutor(
+        exec_cfg=cfg.exec_cfg,
+        runtime=cfg.runtime,
+        running_tasks=running_tasks,
+        scheduler=scheduler,
+        on_thread_known=on_thread_known,
+        engine_overrides_resolver=engine_overrides_resolver,
+        chat_id=chat_id,
+        user_msg_id=user_msg_id,
+        thread_id=msg.thread_id,
+        show_resume_line=cfg.show_resume_line,
+        stateful_mode=stateful_mode,
+        default_engine_override=default_engine_override,
+    )
+    message_ref = MessageRef(
+        channel_id=chat_id,
+        message_id=user_msg_id,
+        thread_id=msg.thread_id,
+        sender_id=msg.sender_id,
+        raw=msg.raw,
+    )
+    try:
+        backend = get_command(command_id, allowlist=allowlist, required=False)
+    except ConfigError as exc:
+        await executor.send(f"error:\n{exc}", reply_to=message_ref, notify=True)
+        return
+    if backend is None:
+        return
+    try:
+        plugin_config = cfg.runtime.plugin_config(command_id)
+    except ConfigError as exc:
+        await executor.send(f"error:\n{exc}", reply_to=message_ref, notify=True)
+        return
+    ctx = CommandContext(
+        command=command_id,
+        text=text,
+        args_text=args_text,
+        args=split_command_args(args_text),
+        message=message_ref,
+        reply_to=reply_ref,
+        reply_text=msg.reply_to_text,
+        config_path=cfg.runtime.config_path,
+        plugin_config=plugin_config,
+        runtime=cfg.runtime,
+        executor=executor,
+    )
+    try:
+        result = await backend.handle(ctx)
+    except Exception as exc:
+        logger.exception(
+            "command.failed",
+            command=command_id,
+            error=str(exc),
+            error_type=exc.__class__.__name__,
+        )
+        await executor.send(f"error:\n{exc}", reply_to=message_ref, notify=True)
+        return
+    if result is not None:
+        reply_to = message_ref if result.reply_to is None else result.reply_to
+        await executor.send(result.text, reply_to=reply_to, notify=result.notify)