revert: remove snippet upload feature (PRs #1262, #1263, #1265) (#1269)

Reverting the Slack snippet upload feature as it doesn't create proper
snippets with line numbers. The Slack API behavior doesn't match
documentation. Will revisit later.

This reverts:
- bec525b fix(slackbot): pass snippet_type to create proper Slack code snippets (#1265)
- e3558f9 fix(slackbot): use files.upload for actual Slack snippets (#1263)
- 08ee978 feat(slackbot): upload long code blocks as Slack snippets (#1262)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

Author: zzstoatzz

examples/slackbot/src/slackbot/_internal/templates.py

@@ -34,24 +34,13 @@
 
 DEFAULT_SYSTEM_PROMPT = """You are Marvin, an AI assistant for the Prefect data engineering platform. Your responses should be clear, helpful, accurate, and professional. Your primary goal is to provide excellent support to users.
 
-## Output Format
-Your responses are structured with interleaved text and code sections. This allows longer code blocks to be displayed as Slack file snippets with proper syntax highlighting.
-
-**For text sections:**
+## Output Context
+Your responses will be displayed in Slack. Format accordingly:
+- Use ``` for code blocks (WITHOUT language identifiers like python/js/etc - Slack doesn't support them)
 - Use single backticks for inline code
 - Bold text uses *asterisks*
 - Links should be formatted as <url|text>
 
-**For code sections:**
-- Provide a descriptive title (e.g., "prefect.yaml", "build_bundle.sh", "example usage")
-- Specify the language for syntax highlighting (e.g., "python", "yaml", "bash")
-- Short code snippets (a few lines) can stay inline in text sections using single backticks
-- Longer code examples should be separate code sections - they'll be uploaded as Slack snippets for better readability
-
-**When to use code sections vs inline code:**
-- Use a CODE SECTION for: complete files, multi-line examples, configuration blocks, shell scripts
-- Use INLINE CODE (in text) for: short one-liners, command names, variable names, brief examples
-
 ## Your Mission
 Your role is to act as the primary assistant for the user. You will receive raw information from specialized tools. Your job is to synthesize this info as usefully as possible.
 Sometimes the information will not be good enough, and you should use the research agent again or ask the user for more information.

examples/slackbot/src/slackbot/api.py

@@ -29,6 +29,7 @@
 from slackbot.assets import summarize_thread
 from slackbot.core import (
     Database,
+    UserContext,
     build_user_context,
     create_agent,
 )
@@ -39,10 +40,8 @@
     get_channel_name,
     get_workspace_domain,
     post_slack_message,
-    post_structured_response,
 )
 from slackbot.strings import count_tokens, slice_tokens
-from slackbot.types import StructuredResponse, UserContext
 from slackbot.wrap import WatchToolCalls, _progress_message, _tool_usage_counts
 
 BOT_MENTION = r"<@(\w+)>"
@@ -76,7 +75,7 @@ async def run_agent(
     channel_id: str,
     thread_ts: str,
     decorator_settings: dict[str, Any] | None = None,
-) -> AgentRunResult[StructuredResponse]:
+) -> AgentRunResult[str]:
     if decorator_settings is None:
         decorator_settings = {
             "cache_policy": NONE,
@@ -267,8 +266,8 @@ async def handle_message(payload: SlackPayload, db: Database):
             await db.add_thread_messages(thread_ts, result.new_messages())
             conversation.extend(result.new_messages())
             assert event.channel is not None, "No channel found"
-            await post_structured_response(
-                response=result.output,
+            await task(post_slack_message)(
+                message=result.output,
                 channel_id=event.channel,
                 thread_ts=thread_ts,
             )

examples/slackbot/src/slackbot/core.py

@@ -42,7 +42,7 @@
     read_github_issues,
 )
 from slackbot.settings import settings
-from slackbot.types import StructuredResponse, UserContext
+from slackbot.types import UserContext
 
 GITHUB_API_TOKEN = Secret.load(settings.github_token_secret_name, _sync=True).get()
 
@@ -162,7 +162,7 @@ def build_user_context(
 
 def create_agent(
     model: KnownModelName | Model | None = None,
-) -> Agent[UserContext, StructuredResponse]:
+) -> Agent[UserContext, str]:
     logger = get_run_logger()
     logger.info("Creating new agent")
     ai_model = model or AnthropicModel(
@@ -174,11 +174,10 @@ def create_agent(
         ),
     )
     agent = Agent[
-        UserContext, StructuredResponse
+        UserContext, str
     ](
         model=ai_model,
         model_settings=ModelSettings(temperature=settings.temperature),
-        output_type=StructuredResponse,
         tools=[
             research_prefect_topic,  # Tool for researching Prefect topics
             read_github_issues,  # For searching GitHub issues

examples/slackbot/src/slackbot/slack.py

@@ -1,21 +1,12 @@
 """Module for Slack-related utilities."""
 
-from __future__ import annotations
-
 import re
-from typing import TYPE_CHECKING, Any, List, Union
-
-if TYPE_CHECKING:
-    from slackbot.types import StructuredResponse
+from typing import Any, List, Union
 
 import httpx
-from prefect.logging.loggers import get_logger
 from pydantic import BaseModel, ValidationInfo, field_validator, model_validator
 
 from slackbot.settings import settings
-from slackbot.types import SNIPPET_LINE_THRESHOLD
-
-logger = get_logger(__name__)
 
 
 class EventBlockElement(BaseModel):
@@ -365,253 +356,3 @@ async def create_progress_message(
     progress = ProgressMessage(channel_id, thread_ts)
     await progress.start(initial_text)
     return progress
-
-
-# --- Slack Snippet Upload (using new API with snippet_type parameter) ---
-
-
-async def upload_snippet(
-    content: str,
-    filename: str,
-    channel_id: str,
-    thread_ts: str | None = None,
-    title: str | None = None,
-    filetype: str | None = None,
-) -> dict[str, Any]:
-    """Upload a code snippet using the new external upload API with snippet_type.
-
-    The snippet_type parameter tells Slack to create a proper code snippet
-    (with syntax highlighting and line numbers) rather than a plain file.
-
-    Uses the three-step process:
-    1. files.getUploadURLExternal - get upload URL, passing snippet_type
-    2. POST content to that URL
-    3. files.completeUploadExternal - finalize and share in channel
-
-    Args:
-        content: The snippet content to upload
-        filename: Filename for the snippet (e.g., "example.py")
-        channel_id: Channel to share the snippet in
-        thread_ts: Thread timestamp to share in (optional)
-        title: Display title for the snippet (optional, defaults to filename)
-        filetype: Syntax type for the snippet (e.g., "python", "javascript", "yaml")
-
-    Returns:
-        dict with file info from Slack API
-    """
-    content_bytes = content.encode("utf-8")
-    length = len(content_bytes)
-
-    async with httpx.AsyncClient() as client:
-        # Step 1: Get upload URL with snippet_type parameter
-        # snippet_type is the key - it tells Slack to create a code snippet
-        # with syntax highlighting and line numbers, not just a plain file
-        get_url_params: dict[str, Any] = {
-            "filename": filename,
-            "length": length,
-        }
-        if filetype:
-            get_url_params["snippet_type"] = filetype
-
-        response = await client.get(
-            "https://slack.com/api/files.getUploadURLExternal",
-            headers={"Authorization": f"Bearer {settings.slack_api_token}"},
-            params=get_url_params,
-        )
-        response.raise_for_status()
-        url_data = response.json()
-
-        if not url_data.get("ok"):
-            raise ValueError(
-                f"Failed to get upload URL: {url_data.get('error', 'unknown error')}"
-            )
-
-        upload_url = url_data["upload_url"]
-        file_id = url_data["file_id"]
-
-        logger.info(f"Got upload URL for file_id={file_id}, snippet_type={filetype}")
-
-        # Step 2: Upload content to the provided URL
-        upload_response = await client.post(
-            upload_url,
-            content=content_bytes,
-            headers={"Content-Type": "application/octet-stream"},
-        )
-        if upload_response.status_code != 200:
-            raise ValueError(
-                f"Failed to upload file content: {upload_response.status_code}"
-            )
-
-        # Step 3: Complete the upload and share in channel
-        complete_payload: dict[str, Any] = {
-            "files": [{"id": file_id, "title": title or filename}],
-            "channel_id": channel_id,
-        }
-        if thread_ts:
-            complete_payload["thread_ts"] = thread_ts
-
-        complete_response = await client.post(
-            "https://slack.com/api/files.completeUploadExternal",
-            headers={
-                "Authorization": f"Bearer {settings.slack_api_token}",
-                "Content-Type": "application/json",
-            },
-            json=complete_payload,
-        )
-        complete_response.raise_for_status()
-        complete_data = complete_response.json()
-
-        if not complete_data.get("ok"):
-            raise ValueError(
-                f"Failed to complete upload: {complete_data.get('error', 'unknown error')}"
-            )
-
-        # Log the resulting file mode to verify snippet creation
-        files = complete_data.get("files", [])
-        if files:
-            file_info = files[0]
-            logger.info(
-                f"Uploaded file - mode: {file_info.get('mode')}, "
-                f"filetype: {file_info.get('filetype')}, "
-                f"editable: {file_info.get('editable')}"
-            )
-
-        return complete_data
-
-
-# Language to file extension mapping for snippet filenames
-LANGUAGE_EXTENSIONS: dict[str, str] = {
-    "python": "py",
-    "py": "py",
-    "javascript": "js",
-    "js": "js",
-    "typescript": "ts",
-    "ts": "ts",
-    "yaml": "yaml",
-    "yml": "yaml",
-    "json": "json",
-    "bash": "sh",
-    "sh": "sh",
-    "shell": "sh",
-    "sql": "sql",
-    "html": "html",
-    "css": "css",
-    "go": "go",
-    "rust": "rs",
-    "java": "java",
-    "c": "c",
-    "cpp": "cpp",
-    "c++": "cpp",
-    "ruby": "rb",
-    "php": "php",
-    "swift": "swift",
-    "kotlin": "kt",
-    "scala": "scala",
-    "r": "r",
-    "dockerfile": "dockerfile",
-    "docker": "dockerfile",
-    "toml": "toml",
-    "ini": "ini",
-    "xml": "xml",
-    "markdown": "md",
-    "md": "md",
-    "text": "txt",
-    "txt": "txt",
-    "plaintext": "txt",
-}
-
-
-def get_extension_for_language(language: str | None) -> str:
-    """Get file extension for a language identifier."""
-    if not language:
-        return "txt"
-    return LANGUAGE_EXTENSIONS.get(language.lower(), "txt")
-
-
-async def post_structured_response(
-    response: StructuredResponse,
-    channel_id: str,
-    thread_ts: str | None = None,
-    snippet_line_threshold: int = SNIPPET_LINE_THRESHOLD,
-) -> None:
-    """Post a structured response to Slack, uploading long code blocks as snippets.
-
-    This renders the response by:
-    1. Collecting text and short code into messages
-    2. Uploading long code blocks as Slack file snippets
-    3. Maintaining the order of sections for readability
-
-    Args:
-        response: The structured response to post
-        channel_id: Slack channel ID
-        thread_ts: Thread timestamp (optional)
-        snippet_line_threshold: Code blocks with more lines than this are uploaded as snippets
-    """
-
-    accumulated_text: list[str] = []
-    snippet_counter = 0
-
-    async def flush_text() -> None:
-        """Post accumulated text as a message."""
-        nonlocal accumulated_text
-        if accumulated_text:
-            text = "\n\n".join(accumulated_text)
-            await post_slack_message(
-                message=text,
-                channel_id=channel_id,
-                thread_ts=thread_ts,
-            )
-            accumulated_text = []
-
-    for section in response.sections:
-        if section.type == "text":
-            accumulated_text.append(section.content)
-        elif section.type == "code":
-            code_lines = section.content.count("\n") + 1
-
-            if code_lines <= snippet_line_threshold:
-                # Short code: inline it in the text
-                # Slack doesn't support language identifiers in code blocks
-                accumulated_text.append(f"```\n{section.content}\n```")
-            else:
-                # Long code: flush text first, then upload as snippet
-                await flush_text()
-
-                snippet_counter += 1
-                ext = get_extension_for_language(section.language)
-
-                # Use title as filename only if it looks like a valid filename
-                # (ends with .ext pattern, no spaces, reasonable length)
-                title_is_filename = (
-                    section.title
-                    and "." in section.title
-                    and section.title.rsplit(".", 1)[-1].lower()
-                    in LANGUAGE_EXTENSIONS.values()
-                    and " " not in section.title
-                    and len(section.title) < 100
-                )
-                filename = (
-                    section.title
-                    if title_is_filename
-                    else f"snippet_{snippet_counter}.{ext}"
-                )
-                title = section.title or f"Code snippet {snippet_counter}"
-
-                try:
-                    await upload_snippet(
-                        content=section.content,
-                        filename=filename,
-                        channel_id=channel_id,
-                        thread_ts=thread_ts,
-                        title=title,
-                        filetype=section.language,
-                    )
-                except (httpx.HTTPError, ValueError, KeyError) as e:
-                    # Fallback: post as regular code block if upload fails
-                    logger.warning(
-                        f"Failed to upload snippet '{title}', falling back to inline: {e}"
-                    )
-                    accumulated_text.append(f"*{title}*\n```\n{section.content}\n```")
-
-    # Flush any remaining text
-    await flush_text()