| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122 |
- """Shared one-off LLM requests for non-conversational helpers.
- A "one-shot" is a single stateless model call outside any conversation (commit
- messages, rename suggestions, summaries): it never touches session history or
- prompt caching. Call with explicit ``instructions``/``user_input`` or a registered
- ``template`` + ``variables`` so prompt engineering stays consistent across
- CLI/TUI/desktop. Model selection rides :func:`agent.auxiliary_client.call_llm`:
- ``main_runtime`` inherits the live session's provider/model, else ``task``
- resolves a cheap backend.
- """
- import logging
- from typing import Any, Callable, Dict, Optional, Tuple
- from agent.auxiliary_client import call_llm, extract_content_or_reasoning
- logger = logging.getLogger(__name__)
- # Templates are plain callables (not str.format) so diff/code payloads with
- # literal "{" / "}" pass through untouched.
- PromptTemplate = Callable[[dict[str, Any]], tuple[str, str]]
- def _truncate(text: str, limit: int) -> str:
- text = text or ""
- return text if len(text) <= limit else text[:limit].rstrip() + "\n…(truncated)"
- _COMMIT_INSTRUCTIONS = (
- "You write git commit messages. Given a diff of staged changes, write ONE concise Conventional Commits "
- "message describing what the change does and why.\n"
- "Rules:\n"
- "- Subject line: type(scope): summary — imperative mood, lower-case, no trailing period, ≤ 72 "
- "characters. Types: feat, fix, refactor, perf, docs, test, build, chore, style, ci.\n"
- "- Omit the scope if it isn't obvious.\n"
- "- Add a short body (wrapped at ~72 cols) ONLY when the change needs explanation; skip it for "
- "small/obvious changes.\n"
- "- Describe the actual change, never restate the diff line-by-line.\n"
- "- Return ONLY the commit message text — no quotes, no markdown fences, no preamble."
- )
- def _commit_message_template(variables: dict[str, Any]) -> tuple[str, str]:
- diff = _truncate(str(variables.get("diff") or ""), 12000)
- recent = _truncate(str(variables.get("recent_commits") or ""), 1500)
- parts = []
- if recent.strip():
- parts.append(
- "Recent commit subjects from this repo (match their style/conventions):\n"
- f"{recent}"
- )
- parts.append("Diff to describe:\n" + (diff or "(no textual diff available)"))
- # "Regenerate" must yield something new even on greedy/server-pinned
- # temperature models; a nonce isn't enough, so hand back the previous
- # message and require a genuinely different one.
- avoid = _truncate(str(variables.get("avoid") or "").strip(), 1000)
- if avoid:
- parts.append(
- "You already proposed the message below and the user wants a different one. Write a NEW message with "
- "different wording (and, if reasonable, a different emphasis or scope framing) — do not repeat "
- f"it:\n{avoid}"
- )
- return _COMMIT_INSTRUCTIONS, "\n\n".join(parts)
- # Registry of named templates; add an entry to give a new surface a reusable prompt.
- PROMPT_TEMPLATES: dict[str, PromptTemplate] = {
- "commit_message": _commit_message_template,
- }
- def render_template(name: str, variables: Optional[dict[str, Any]] = None) -> tuple[str, str]:
- """Resolve a registered template into (instructions, user_input); KeyError if unknown."""
- template = PROMPT_TEMPLATES.get(name)
- if template is None:
- raise KeyError(f"unknown one-shot template: {name}")
- return template(variables or {})
- def run_oneshot(
- *,
- instructions: str = "",
- user_input: str = "",
- template: Optional[str] = None,
- variables: Optional[dict[str, Any]] = None,
- task: str = "title_generation",
- max_tokens: int = 1024,
- temperature: Optional[float] = 0.3,
- timeout: float = 60.0,
- main_runtime: Optional[dict[str, Any]] = None,
- ) -> str:
- """Run a single stateless LLM request and return its text (fence-stripped).
- Raises RuntimeError when no provider is configured (from :func:`call_llm`),
- KeyError for an unknown template, ValueError when the prompt is empty.
- """
- if template:
- instructions, user_input = render_template(template, variables)
- has_instructions = bool((instructions or "").strip())
- if not has_instructions and not (user_input or "").strip():
- raise ValueError("run_oneshot requires a template or instructions/user_input")
- messages = [{"role": "system", "content": instructions}] if has_instructions else []
- messages.append({"role": "user", "content": user_input or ""})
- response = call_llm(
- task=task,
- messages=messages,
- max_tokens=max_tokens,
- temperature=temperature,
- timeout=timeout,
- main_runtime=main_runtime,
- )
- return _strip_code_fence((extract_content_or_reasoning(response) or "").strip())
- def _strip_code_fence(text: str) -> str:
- """Drop a single wrapping ``` fence the model may have added."""
- if not text.startswith("```"):
- return text
- lines = text.splitlines()
- if len(lines) >= 2 and lines[-1].strip() == "```":
- return "\n".join(lines[1:-1]).strip()
- return text
|