Background thoughts.

Author: payneio

assistants/knowledge-transfer-assistant/assistant/agentic/__init__.py

@@ -0,0 +1,13 @@
+from types import SimpleNamespace
+
+from .coordinator_next_action import get_coordinator_next_action_suggestion
+from .detect_audience_and_takeaways import detect_audience_and_takeaways
+from .team_welcome import generate_team_welcome_message
+from .update_digest import update_digest
+
+agentic = SimpleNamespace(
+    get_coordinator_next_action_suggestion=get_coordinator_next_action_suggestion,
+    detect_audience_and_takeaways=detect_audience_and_takeaways,
+    generate_team_welcome_message=generate_team_welcome_message,
+    update_digest=update_digest,
+)

assistants/knowledge-transfer-assistant/assistant/agentic/coordinator_next_action.py

@@ -0,0 +1,115 @@
+"""
+Coordinator support and helper functions for Knowledge Transfer Assistant.
+
+Provides next action suggestions and other coordinator utilities.
+"""
+
+from semantic_workbench_assistant.assistant_app import ConversationContext
+
+from assistant.data import RequestStatus
+from assistant.domain import ShareManager, TransferManager
+from assistant.logging import logger
+
+
+async def get_coordinator_next_action_suggestion(
+    context: ConversationContext,
+) -> str | None:
+    """
+    Generate next action suggestions for the coordinator based on the knowledge transfer state.
+
+    This output is passed to the assistant and helps guide the conversation toward completing or improving
+    the knowledge share in a helpful, structured way.
+
+    Returns:
+        A user-facing suggestion string, or None if no suggestion is needed.
+    """
+    try:
+        share_id = await ShareManager.get_share_id(context)
+        if not share_id:
+            logger.warning("No share ID found for this conversation")
+            return None
+
+        share = await ShareManager.get_share(context)
+        if not share:
+            return None
+
+        brief = share.brief
+        requests = share.requests
+        active_requests = [r for r in requests if r.status == RequestStatus.NEW]
+
+        # 1. Unresolved requests come first
+        if active_requests:
+            request = active_requests[0]
+            return (
+                f"There are {len(active_requests)} unanswered questions from team members. "
+                f'One of them is: "{request.title}" Let\'s work on answering it.'
+            )
+
+        # 2. Audience not yet defined
+        if not share.audience:
+            return (
+                "Let's start by defining who your audience is. Who is this knowledge for, and what's their background?"
+            )
+
+        # 3. Knowledge not yet organized
+        # if not share.knowledge_organized:
+        #     return (
+        #         "Next, let's organize your knowledge. Upload any relevant files or describe the knowledge "
+        #         "you want to transfer. When you're ready, I can mark the knowledge as organized."
+        #     )
+
+        # 4. Brief not yet written
+        if not brief:
+            return (
+                "Your knowledge share-out needs a short introduction that will orient your team. "
+                "Let's write a knowledge brief next. The knowledge brief helps your team understand "
+                "the purpose of this knowledge transfer and will be visible to all team members in their side panel."
+            )
+
+        # 5. If intended to have outcomes but none defined yet
+        if share.is_intended_to_accomplish_outcomes and not share.learning_objectives:
+            return (
+                "Would you like your team to achieve any specific outcomes? If so, let's define some learning objectives. "  # noqa: E501
+                "If not, you can mark this share-out as 'exploratory' instead."
+            )
+
+        # 6. Objectives exist, but missing outcomes
+        if share.is_intended_to_accomplish_outcomes:
+            incomplete_objectives = [obj for obj in share.learning_objectives if not obj.learning_outcomes]
+            if incomplete_objectives:
+                name = incomplete_objectives[0].name
+                return (
+                    f"The learning objective '{name}' doesn't have any outcomes yet. "
+                    f"Let's define what your team should accomplish to meet it."
+                )
+
+        # 7. Ready for transfer but not yet shared
+        if TransferManager.is_ready_for_transfer(share) and not TransferManager.is_actively_sharing(share):
+            return (
+                "Your knowledge is ready to share. Would you like to create a message and generate the invitation link?"
+            )
+
+        # 8. Actively sharing - monitor and support ongoing transfer
+        if TransferManager.is_actively_sharing(share):
+            if share.is_intended_to_accomplish_outcomes and not TransferManager._is_transfer_complete(share):
+                team_count = len(share.team_conversations)
+                return (
+                    f"Great! Your knowledge is being shared with {team_count} team member"
+                    f"{'s' if team_count != 1 else ''}. You can continue improving the knowledge share or "
+                    f"respond to information requests as they come in."
+                )
+            else:
+                return (
+                    "Your knowledge transfer is in progress. You can continue improving the knowledge share or "
+                    "respond to information requests as they come in."
+                )
+
+        # 9. Default: General support
+        return (
+            "Your knowledge share is available. You can continue improving it or "
+            "respond to new information requests as they come in."
+        )
+
+    except Exception as e:
+        logger.exception(f"Error generating next action suggestion: {e}")
+        return None

assistants/knowledge-transfer-assistant/assistant/agentic/coordinator_support.py

@@ -0,0 +1,116 @@
+"""
+Analysis and detection functions for the knowledge transfer assistant.
+
+This module contains functions for analyzing messages and knowledge transfer content
+to detect specific conditions, such as information request needs.
+"""
+
+from typing import Any
+
+import openai_client
+from assistant_extensions.attachments import AttachmentsExtension
+from pydantic import BaseModel
+from semantic_workbench_assistant.assistant_app import ConversationContext
+
+from assistant.config import assistant_config
+from assistant.data import InspectorTab
+from assistant.domain.share_manager import ShareManager
+from assistant.domain.thoughts_manager import ThoughtsManager
+from assistant.logging import logger
+from assistant.notifications import Notifications
+from assistant.prompt_utils import (
+    ContextSection,
+    ContextStrategy,
+    Instructions,
+    Prompt,
+    add_context_to_prompt,
+)
+from assistant.utils import load_text_include
+
+
+async def detect_audience_and_takeaways(
+    context: ConversationContext, attachments_extension: AttachmentsExtension
+) -> None:
+    debug: dict[str, Any] = {
+        "context": context,
+    }
+
+    config = await assistant_config.get(context.assistant)
+
+    # Set up prompt instructions.
+    audience_instructions = load_text_include("background_thought_audience.md")
+    instructions = Instructions(audience_instructions)
+    prompt = Prompt(
+        role=config.prompt_config.coordinator_role,
+        instructions=instructions,
+        context_strategy=ContextStrategy.MULTI,
+    )
+
+    # Add prompt context.
+    role = await ShareManager.get_conversation_role(context)
+    await add_context_to_prompt(
+        prompt,
+        context=context,
+        role=role,
+        model=config.request_config.openai_model,
+        token_limit=config.request_config.max_tokens,
+        attachments_extension=attachments_extension,
+        attachments_config=config.attachments_config,
+        attachments_in_system_message=True,
+        include=[
+            # ContextSection.KNOWLEDGE_INFO,
+            # ContextSection.KNOWLEDGE_BRIEF,
+            ContextSection.TARGET_AUDIENCE,
+            ContextSection.LEARNING_OBJECTIVES,
+            # ContextSection.KNOWLEDGE_DIGEST,
+            # ContextSection.INFORMATION_REQUESTS,
+            # ContextSection.SUGGESTED_NEXT_ACTIONS,
+            ContextSection.COORDINATOR_CONVERSATION,
+            ContextSection.ATTACHMENTS,
+            ContextSection.ASSISTANT_THOUGHTS,
+        ],
+    )
+
+    class Output(BaseModel):
+        """Output class to hold the generated thoughts."""
+
+        thoughts: list[
+            str
+        ]  # Generated thoughts about the audience and takeaways. One thought per item. If there are no thoughts, this will be an empty list. #noqa: E501
+
+    # Chat completion
+    async with openai_client.create_client(config.service_config) as client:
+        try:
+            completion_args = {
+                "messages": prompt.messages(),
+                "model": config.request_config.openai_model,
+                "max_tokens": 500,
+                "temperature": 0.8,
+                "response_format": Output,
+            }
+            debug["completion_args"] = openai_client.make_completion_args_serializable(completion_args)
+
+            # LLM call
+            response = await client.beta.chat.completions.parse(
+                **completion_args,
+            )
+            openai_client.validate_completion(response)
+            debug["completion_response"] = openai_client.add_serializable_data(response.model_dump())
+
+            # Response
+            if response and response.choices and response.choices[0].message.parsed:
+                output: Output = response.choices[0].message.parsed
+                if output.thoughts:
+                    await ThoughtsManager.add_assistant_thoughts(context, output.thoughts)
+                    await Notifications.notify_state_update(
+                        context,
+                        [InspectorTab.BRIEF],
+                    )
+            else:
+                logger.warning("Empty response from LLM for welcome message generation")
+
+        except Exception as e:
+            logger.exception(f"Failed to make OpenIA call: {e}")
+            debug["error"] = str(e)
+
+    logger.debug(f"{__name__}: {debug}")