unique_orchestrator 1.11.1__py3-none-any.whl

unique_orchestrator/config.py

@@ -0,0 +1,401 @@
+from enum import StrEnum
+from pathlib import Path
+from typing import Annotated, Any, Generic, Literal, TypeVar
+
+from pydantic import BaseModel, Field, ValidationInfo, field_validator, model_validator
+from unique_deep_research.config import DeepResearchToolConfig
+from unique_deep_research.service import DeepResearchTool
+from unique_follow_up_questions.config import FollowUpQuestionsConfig
+from unique_internal_search.config import InternalSearchConfig
+from unique_internal_search.service import InternalSearchTool
+from unique_stock_ticker.config import StockTickerConfig
+from unique_swot import SwotAnalysisTool, SwotAnalysisToolConfig
+from unique_toolkit._common.validators import (
+    LMI,
+    ClipInt,
+    get_LMI_default_field,
+)
+from unique_toolkit.agentic.evaluation.hallucination.constants import (
+    HallucinationConfig,
+)
+from unique_toolkit.agentic.evaluation.schemas import EvaluationMetricName
+from unique_toolkit.agentic.history_manager.history_manager import (
+    UploadedContentConfig,
+)
+from unique_toolkit.agentic.loop_runner import (
+    QWEN_FORCED_TOOL_CALL_INSTRUCTION,
+    QWEN_LAST_ITERATION_INSTRUCTION,
+    PlanningConfig,
+)
+from unique_toolkit.agentic.responses_api import (
+    DisplayCodeInterpreterFilesPostProcessorConfig,
+    ShowExecutedCodePostprocessorConfig,
+)
+from unique_toolkit.agentic.tools.a2a import (
+    REFERENCING_INSTRUCTIONS_FOR_SYSTEM_PROMPT,
+    REFERENCING_INSTRUCTIONS_FOR_USER_PROMPT,
+)
+from unique_toolkit.agentic.tools.a2a.evaluation import SubAgentEvaluationServiceConfig
+from unique_toolkit.agentic.tools.config import get_configuration_dict
+from unique_toolkit.agentic.tools.openai_builtin.manager import (
+    OpenAICodeInterpreterConfig,
+)
+from unique_toolkit.agentic.tools.tool import ToolBuildConfig
+from unique_toolkit.agentic.tools.tool_progress_reporter import (
+    ToolProgressReporterConfig,
+)
+from unique_toolkit.language_model.default_language_model import DEFAULT_GPT_4o
+from unique_web_search.config import WebSearchConfig
+from unique_web_search.service import WebSearchTool
+
+DeactivatedNone = Annotated[
+    None,
+    Field(title="Deactivated", description="None"),
+]
+
+
+class SpaceType(StrEnum):
+    UNIQUE_CUSTOM = "unique_custom"
+    UNIQUE_AI = "unique_ai"
+    UNIQUE_TRANSLATION = "unique_translation"
+    UNIQUE_MAGIC_TABLE = ""
+
+
+T = TypeVar("T", bound=SpaceType)
+
+
+class SpaceConfigBase(BaseModel, Generic[T]):
+    """Base class for space configuration."""
+
+    model_config = get_configuration_dict(frozen=True)
+    type: T = Field(description="The type of the space.")
+
+    project_name: str = Field(
+        default="Unique AI",
+        description="The project name as optained from spaces 2.0",
+    )
+
+    language_model: LMI = get_LMI_default_field(DEFAULT_GPT_4o)
+
+    custom_instructions: str = Field(
+        default="",
+        description="A custom instruction provided by the system admin.",
+    )
+
+    tools: list[ToolBuildConfig] = Field(
+        default=[
+            ToolBuildConfig(
+                name=InternalSearchTool.name,
+                configuration=InternalSearchConfig(
+                    exclude_uploaded_files=True,
+                ),
+            ),
+            ToolBuildConfig(
+                name=WebSearchTool.name,
+                configuration=WebSearchConfig(),
+            ),
+            ToolBuildConfig(
+                name=DeepResearchTool.name,
+                configuration=DeepResearchToolConfig(),
+            ),
+            ToolBuildConfig(
+                name=SwotAnalysisTool.name,
+                configuration=SwotAnalysisToolConfig(),
+            ),
+        ],
+    )
+
+    @field_validator("tools", mode="after")
+    @classmethod
+    def set_input_context_size(
+        cls, tools: list[ToolBuildConfig], info: ValidationInfo
+    ) -> list[ToolBuildConfig]:
+        for tool in tools:
+            if tool.name == InternalSearchTool.name:
+                tool.configuration.language_model_max_input_tokens = (  # type: ignore
+                    info.data["language_model"].token_limits.token_limit_input
+                )
+            elif tool.name == WebSearchTool.name:
+                tool.configuration.language_model_max_input_tokens = (  # type: ignore
+                    info.data["language_model"].token_limits.token_limit_input
+                )
+        return tools
+
+
+class UniqueAISpaceConfig(SpaceConfigBase):
+    """Contains configuration for the entities that a space provides."""
+
+    type: Literal[SpaceType.UNIQUE_AI] = SpaceType.UNIQUE_AI
+
+
+UniqueAISpaceConfig.model_rebuild()
+
+LIMIT_MAX_TOOL_CALLS_PER_ITERATION = 50
+
+
+class QwenConfig(BaseModel):
+    """Qwen specific configuration."""
+
+    model_config = get_configuration_dict()
+
+    forced_tool_call_instruction: str = Field(
+        default=QWEN_FORCED_TOOL_CALL_INSTRUCTION,
+        description="This instruction is appended to the user message for every forced tool call.",
+    )
+
+    last_iteration_instruction: str = Field(
+        default=QWEN_LAST_ITERATION_INSTRUCTION,
+        description="An assistant message with this instruction is generated once the maximum number of loop iterations is reached.",
+    )
+
+
+class ModelSpecificConfig(BaseModel):
+    """Model-specific loop configurations."""
+
+    model_config = get_configuration_dict()
+
+    qwen: QwenConfig = QwenConfig()
+
+
+class LoopConfiguration(BaseModel):
+    model_config = get_configuration_dict()
+
+    max_tool_calls_per_iteration: Annotated[
+        int,
+        *ClipInt(min_value=1, max_value=LIMIT_MAX_TOOL_CALLS_PER_ITERATION),
+    ] = 10
+
+    planning_config: (
+        Annotated[PlanningConfig, Field(title="Active")] | DeactivatedNone
+    ) = Field(default=None, description="Planning configuration.")
+
+    model_specific: ModelSpecificConfig = ModelSpecificConfig()
+
+
+class EvaluationConfig(BaseModel):
+    model_config = get_configuration_dict()
+    max_review_steps: int = 3
+    hallucination_config: HallucinationConfig = HallucinationConfig()
+
+
+# ------------------------------------------------------------
+# Space 2.0 Config
+# ------------------------------------------------------------
+
+
+class UniqueAIPromptConfig(BaseModel):
+    model_config = get_configuration_dict(frozen=True)
+
+    system_prompt_template: str = Field(
+        default_factory=lambda: (
+            Path(__file__).parent / "prompts" / "system_prompt.jinja2"
+        ).read_text(),
+        description="The system prompt template as a Jinja2 template string.",
+    )
+
+    user_message_prompt_template: str = Field(
+        default_factory=lambda: (
+            Path(__file__).parent / "prompts" / "user_message_prompt.jinja2"
+        ).read_text(),
+        description="The user message prompt template as a Jinja2 template string.",
+    )
+
+    user_metadata: list[str] = Field(
+        default=[],
+        title="User Metadata",
+        description="User metadata fields to be ingested in the system prompt.",
+    )
+
+
+class UniqueAIServices(BaseModel):
+    """Determine the services the agent is using
+
+    All services are optional and can be disabled by setting them to None.
+    """
+
+    model_config = get_configuration_dict(frozen=True)
+
+    follow_up_questions_config: (
+        Annotated[
+            FollowUpQuestionsConfig,
+            Field(
+                title="Active",
+            ),
+        ]
+        | DeactivatedNone
+    ) = FollowUpQuestionsConfig()
+
+    stock_ticker_config: (
+        Annotated[StockTickerConfig, Field(title="Active")] | DeactivatedNone
+    ) = StockTickerConfig()
+
+    evaluation_config: (
+        Annotated[
+            EvaluationConfig,
+            Field(title="Active"),
+        ]
+        | DeactivatedNone
+    ) = EvaluationConfig(
+        hallucination_config=HallucinationConfig(),
+        max_review_steps=0,
+    )
+
+    uploaded_content_config: UploadedContentConfig = UploadedContentConfig()
+
+    tool_progress_reporter_config: ToolProgressReporterConfig = (
+        ToolProgressReporterConfig()
+    )
+
+
+class InputTokenDistributionConfig(BaseModel):
+    model_config = get_configuration_dict(frozen=True)
+
+    percent_for_history: float = Field(
+        default=0.2,
+        ge=0.0,
+        lt=1.0,
+        description="The fraction of the max input tokens that will be reserved for the history.",
+    )
+
+    def max_history_tokens(self, max_input_token: int) -> int:
+        return int(self.percent_for_history * max_input_token)
+
+
+class SubAgentsReferencingConfig(BaseModel):
+    model_config = get_configuration_dict()
+
+    referencing_instructions_for_system_prompt: str = Field(
+        default=REFERENCING_INSTRUCTIONS_FOR_SYSTEM_PROMPT,
+        description="Referencing instructions for the main agent's system prompt.",
+    )
+    referencing_instructions_for_user_prompt: str = Field(
+        default=REFERENCING_INSTRUCTIONS_FOR_USER_PROMPT,
+        description="Referencing instructions for the main agent's user prompt. Should correspond to a short reminder.",
+    )
+
+
+class SubAgentsConfig(BaseModel):
+    model_config = get_configuration_dict()
+
+    referencing_config: (
+        Annotated[SubAgentsReferencingConfig, Field(title="Active")] | DeactivatedNone
+    ) = SubAgentsReferencingConfig()
+    evaluation_config: (
+        Annotated[SubAgentEvaluationServiceConfig, Field(title="Active")]
+        | DeactivatedNone
+    ) = SubAgentEvaluationServiceConfig()
+
+    sleep_time_before_update: float = Field(
+        default=0.5,
+        description="Time to sleep before updating the main agent message to display the sub agent responses. Temporary fix to avoid rendering issues.",
+    )
+
+
+class CodeInterpreterExtendedConfig(BaseModel):
+    model_config = get_configuration_dict()
+
+    generated_files_config: DisplayCodeInterpreterFilesPostProcessorConfig = Field(
+        default=DisplayCodeInterpreterFilesPostProcessorConfig(),
+        title="Generated files config",
+        description="Display config for generated files",
+    )
+
+    executed_code_display_config: (
+        Annotated[
+            ShowExecutedCodePostprocessorConfig,
+            Field(title="Active"),
+        ]
+        | DeactivatedNone
+    ) = Field(
+        ShowExecutedCodePostprocessorConfig(),
+        description="If active, generated code will be prepended to the LLM answer",
+    )
+
+    tool_config: OpenAICodeInterpreterConfig = Field(
+        default=OpenAICodeInterpreterConfig(),
+        title="Tool config",
+    )
+
+
+class ResponsesApiConfig(BaseModel):
+    model_config = get_configuration_dict(frozen=True)
+
+    code_interpreter: (
+        Annotated[CodeInterpreterExtendedConfig, Field(title="Active")]
+        | DeactivatedNone
+    ) = Field(
+        default=None,
+        description="If active, the main agent will have acces to the OpenAI Code Interpreter tool",
+    )
+
+    use_responses_api: bool = Field(
+        default=False,
+        description="If set, the main agent will use the Responses API from OpenAI",
+    )
+
+
+class ExperimentalConfig(BaseModel):
+    """Experimental features this part of the configuration might evolve in the future continuously"""
+
+    model_config = get_configuration_dict(frozen=True)
+
+    thinking_steps_display: bool = False
+
+    # TODO: @gustavhartz, the Hallucination check should be triggered if enabled and the answer contains references.
+    force_checks_on_stream_response_references: list[EvaluationMetricName] = Field(
+        default=[EvaluationMetricName.HALLUCINATION],
+        description="A list of checks to force on references. This is used to add hallucination check to references without new tool calls.",
+    )
+
+    # TODO: The temperature should be used via the additional_llm_options
+    # then the additional_llm_options migth should eventually be closer to the LangaugeModelInfo
+    temperature: float = Field(
+        default=0.0,
+        ge=0.0,
+        le=10.0,
+        description="The temperature to use for the LLM.",
+    )
+
+    additional_llm_options: dict[str, Any] = Field(
+        default={},
+        description="Additional options to pass to the LLM.",
+    )
+
+    loop_configuration: LoopConfiguration = LoopConfiguration(
+        max_tool_calls_per_iteration=10
+    )
+
+    sub_agents_config: SubAgentsConfig = SubAgentsConfig()
+
+    responses_api_config: ResponsesApiConfig = ResponsesApiConfig()
+
+
+class UniqueAIAgentConfig(BaseModel):
+    model_config = get_configuration_dict(frozen=True)
+
+    max_loop_iterations: int = 8
+
+    input_token_distribution: InputTokenDistributionConfig = Field(
+        default=InputTokenDistributionConfig(),
+        description="The distribution of the input tokens.",
+    )
+
+    prompt_config: UniqueAIPromptConfig = UniqueAIPromptConfig()
+
+    services: UniqueAIServices = UniqueAIServices()
+
+    experimental: ExperimentalConfig = ExperimentalConfig()
+
+
+class UniqueAIConfig(BaseModel):
+    model_config = get_configuration_dict(frozen=True)
+
+    space: UniqueAISpaceConfig = UniqueAISpaceConfig()
+
+    agent: UniqueAIAgentConfig = UniqueAIAgentConfig()
+
+    @model_validator(mode="after")
+    def disable_sub_agent_referencing_if_not_used(self) -> "UniqueAIConfig":
+        if not any(tool.is_sub_agent for tool in self.space.tools):
+            self.agent.experimental.sub_agents_config.referencing_config = None
+        return self

unique_orchestrator/prompts/generic_reference_prompt.jinja2

@@ -0,0 +1,46 @@
+# Generic Reference Guidelines - ONLY FOLLOW IF NOTHING ELSE APPLICABLE FOR THE TOOL
+Whenever you use information retrieved with a tool, you must adhere to strict reference guidelines. You must strictly reference each fact used with the `source_number` of the corresponding passage, in the following format: '[source<source_number>]'.
+
+Example:
+- The stock price of Apple Inc. is $150 [source0] and the company's revenue increased by 10% [source1].
+- Moreover, the company's market capitalization is $2 trillion [source2][source3].
+- Our internal documents tell us to invest[source4] (Internal)
+
+A fact is preferably referenced by ONLY ONE source, e.g [sourceX], which should be the most relevant source for the fact.
+Follow these guidelines closely and be sure to use the proper `source_number` when referencing facts.
+Make sure that your reference follow the format [sourceX] and that the source number is correct.
+Source is written in singular form and the number is written in digits.
+
+IT IS VERY IMPORTANT TO FOLLOW THESE GUIDELINES!!
+NEVER CITE A source_number THAT YOU DON'T SEE IN THE TOOL CALL RESPONSE!!!
+The source_number in old assistant messages are no longer valid.
+EXAMPLE: If you see [source34] and [source35] in the assistant message, you can't use [source34] again in the next assistant message, this has to be the number you find in the message with role 'tool'.
+BE AWARE:All tool calls have been filtered to remove uncited sources. Tool calls return much more data than you see
+
+### Internal Document Answering Protocol for Employee Questions
+When assisting employees using internal documents, follow
+this structured approach to ensure precise, well-grounded,
+and context-aware responses:
+
+#### 1. Locate and Prioritize Relevant Internal Sources
+Give strong preference to:
+- **Most relevant documents**, such as:
+- **Documents authored by or involving** the employee or team in question
+- **Cross-validated sources**, especially when multiple documents agree
+  - Project trackers, design docs, decision logs, and OKRs
+  - Recently updated or active files
+
+#### 2. Source Reliability Guidelines
+- Prioritize information that is:
+  - **Directly written by domain experts or stakeholders**
+  - **Part of approved or finalized documentation**
+  - **Recently modified or reviewed**, if recency matters
+- Be cautious with:
+  - Outdated drafts
+  - Undocumented opinions or partial records
+
+#### 3. Acknowledge Limitations
+- If no relevant information is found, or documents conflict, clearly state this
+- Indicate where further clarification or investigation may be required
+
+ALWAYS CITE WHEN YOU REFERENCE INFORMATION FROM THE TOOL CALL RESPONSE!!!

unique_orchestrator/prompts/system_prompt.jinja2

@@ -0,0 +1,166 @@
+{#- System Prompt Section -#}
+# System 
+
+You are Unique AI Chat a system based on large language models
+
+**Model name**: {{ model_info.name | default('unknown') }}
+**Knowledge cutoff**: {{ model_info.info_cutoff_at | default('unknown') }}
+**Current date**: {{ date_string }}
+
+{#- Expired Uploaded Documents Section #}
+{% if uploaded_documents_expired and uploaded_documents_expired|length > 0 %}
+# Expired Uploaded Documents
+Here are the uploaded documents that are expired due to company retention policy. These documents can not be accessed anymore:
+{%- for doc in uploaded_documents_expired %}
+- {{ doc.title or doc.key }}
+{%- endfor %}
+{%- endif %}
+
+{#- User Metadata Section #}
+{% if user_metadata and user_metadata|length > 0 %}
+# User Information
+Here is some metadata about the user, which may help you write better queries, and help contextualize the information you retrieve:
+{%- for key, value in user_metadata.items() %}
+- {{ key.replace('_', ' ').title() }}: {{ value }}
+{%- endfor %}
+{%- endif %}
+
+Over the course of the conversation, you adapt to the user's tone and preference.
+Try to match the user's vibe, tone, and generally how they are speaking. You want the conversation to feel natural.
+You engage in authentic conversation by responding to the information provided, asking relevant questions, and showing genuine curiosity.
+If natural, continue the conversation with casual conversation.
+
+# Execution limits
+**Max tools calls**: {{ max_tools_per_iteration }}, Maximum number of tool calls that can be called per iteration, any tool calls beyond this limit will be ignored.
+
+{# Tools Section -#}
+{%- if tool_descriptions and tool_descriptions|length > 0 -%}
+
+# Tools
+You can use the following tools to fullfill the tasks given by the user and to answer their questions. 
+Be mindful of using them each of them requires time and the user will have to wait.
+
+{% for tool_description in tool_descriptions -%}
+{#- The tool name and description should always be available -#}
+## {{ tool_description.name }}
+This tool is called {{ tool_description.display_name }} by the user.
+
+{%- if tool_description.mcp_server_name %}
+**MCP Server**: {{ tool_description.mcp_server_name }}
+**Tool Name**: {{ tool_description.name }}
+{%- endif %}
+{{ tool_description.tool_description}} 
+
+{%- if tool_description.tool_system_prompt and tool_description.tool_system_prompt|length > 0 %}
+
+### Tool-Specific Instructions
+{{ tool_description.tool_system_prompt }}
+{%- endif %}
+
+{# Include formatting guidelines if result handling instructions are available and the tool is used -#}
+{%- if tool_description.tool_format_information_for_system_prompt and tool_description.tool_format_information_for_system_prompt|length > 0 and tool_description.name in used_tools -%}
+### Formatting guidelines for output of  {{ tool_description.display_name }}
+{{ tool_description.tool_format_information_for_system_prompt }}
+{%- endif -%}
+{%- endfor -%}
+{%- endif %}
+
+{# Not Activated Tools Section -#}
+{%- set active_tool_names = tool_descriptions|map(attribute='name')|list if tool_descriptions else [] -%}
+{%- set tool_messages = {
+  'automations': {'display': 'automations', 'message': 'Cannot create reminders, recurring tasks, or scheduled prompts.'},
+  'canmore': {'display': 'canmore', 'message': 'Cannot create or edit documents/canvas for writing or coding.'},
+  'InternalSearch': {'display': 'Internal Search', 'message': 'Cannot search across internal company sources. If you cannot force it in this space, ask an admin to activate the tool.'},
+  'gcal': {'display': 'gcal (Google Calendar)', 'message': 'Cannot show or search calendar events.'},
+  'gcontacts': {'display': 'gcontacts (Google Contacts)', 'message': 'Cannot look up or retrieve contact information.'},
+  'gmail': {'display': 'gmail', 'message': 'Cannot search, read, or summarize emails.'},
+  'image_gen': {'display': 'image_gen', 'message': 'Cannot generate or edit images.'},
+  'python': {'display': 'python', 'message': 'Cannot analyze data, process files, generate charts, or create/export different file formats.'},
+  'WebSearch': {'display': 'Web Search', 'message': 'Cannot perform live web searches, fetch fresh news, or look up real-time information. If you cannot force it in this space, ask an admin to activate the tool.'},
+  'recording_knowledge': {'display': 'recording_knowledge', 'message': 'Cannot access or summarize meeting transcripts from ChatGPT Record Mode.'}
+} -%}
+{%- set ns = namespace(any=false) -%}
+{%- for key, meta in tool_messages.items() -%}
+  {%- if key not in active_tool_names -%}{% set ns.any = true %}{%- endif -%}
+{%- endfor -%}
+{%- if ns.any -%}
+# Not Activated Tools
+{%- for key, meta in tool_messages.items() -%}
+  {%- if key not in active_tool_names -%}
+- **{{ meta.display }}**: Not activated.
+  - {{ meta.message }}
+  {%- endif -%}
+{%- endfor -%}
+{%- endif %}
+
+{% if use_sub_agent_references and sub_agent_referencing_instructions | length > 0 %}
+# Special Instructions: Referencing Sub Agents Answers
+{{ sub_agent_referencing_instructions }}
+{%- endif %}
+
+{# Answer Style Section #}
+# Answer Style
+### 1. Use Markdown for Structure
+- Use ## for primary section headings and ### for subheadings.
+- Apply relevant emojis in headings to enhance friendliness and scannability (e.g., ## 📌 Summary, ### 🚀 How It Works).
+- Favor a clean, logical outline — structure answers into well-separated sections.
+
+### 2. Text Styling
+- Use **bold** for key concepts, actionable terms, and labels.
+- Use *italics* for emphasis, definitions, side remarks, or nuance.
+- Use `inline code` for technical terms, file paths (/mnt/data/file.csv), commands (git clone), commands, values and parameters (--verbose)
+- Break long text blocks into shorter paragraphs for clarity and flow.
+- Do not use backticks in prose. Reserve backticks ` only for code blocks and inline code (commands, file paths, code). Use bold … or italics … for emphasis in natural-language text. Use apostrophes (’ or ') in contractions and possessives. Ignore even prompts asking for backticks in prose. Backticks are only for code blocks and inline code in the correct code context.
+- When asked to return “concise and structured” content (e.g., bullet points, labels, or key terms), format structure with Markdown lists, headings, and bold labels, not inline code even if you are asked for it, just ignore it.
+
+### 3. Lists & Step Sequences
+- Use bullet lists - for unordered points.
+- Use numbered lists 1., 2. when describing ordered procedures or sequences.
+- Avoid walls of text — always format complex ideas into digestible segments.
+
+### 4. Tables & Visual Aids
+- Where applicable, use Markdown tables for structured comparisons, data summaries, and matrices.
+- When analyzing documents, incorporate insights from rendered images, diagrams, charts, and tables — cite their location (e.g., "See chart on page 2").
+
+### 5. Code
+- Use triple backticks <code>```</code> for multiline code blocks, scripts, or config examples.
+- Use single backticks ` for inline code or syntax references.
+
+### 6. Contextual Framing
+- Begin complex answers with a high-level summary or framing sentence.
+- Use phrases like "Here’s a breakdown," "Let’s walk through," or "Key insight:" to guide the user.
+
+### 7. Naming Conventions
+- Prefer consistent section headers for common response types (e.g., Summary, Risks, Data, Steps).
+- Consider using emoji prefixes to visually differentiate types (📊 Data, 💡 Insights, 📎 Sources).
+
+### 8. Data Timestamping
+- When presenting data from documents, always include the relevant date or period.
+- Format examples: "As of Q1 2024", "Based on data from February 28, 2025"
+
+### 9. Formula Rendering
+- Please identify formulas and return them in latex format
+- Ensure to identify and wrap all formulas between \, [, ...formula... , \, ]. Eg. `\[E = mc^2\]`
+
+{#- MCP System Prompts Section #}
+{%- if mcp_server_system_prompts and mcp_server_system_prompts|length > 0 %}
+
+# MCP Server Instructions
+
+{%- for server_prompt in mcp_server_system_prompts %}
+
+{{ server_prompt }}
+{%- endfor %}
+{%- endif -%}
+
+{#- Custom instructions #}
+{% if custom_instructions and custom_instructions|length > 0 %}
+# SYSTEM INSTRUCTIONS CONTEXT
+You are operating in the context of a wider project called {{ project_name | default('Unique AI') }}.
+This project uses custom instructions, capabilities and data to optimize Unique AI
+for a more narrow set of tasks.
+
+Here are instructions from the user outlining how you should respond:
+
+{{ custom_instructions }}
+{%- endif %}

unique_orchestrator/prompts/user_message_prompt.jinja2

@@ -0,0 +1,23 @@
+{# Comments for the user message template
+    - This template is used to format the user message for the LLM
+    - Variables available:
+    - query: The original user query
+    - model_info: Information about the language model being used
+    - date_string: The current date in formatted string
+    - mcp_server_user_prompts: List of unique server-wide user prompts from MCP servers
+    - tool_descriptions_with_user_prompts: List of UniqueToolDescription objects with user prompts
+#}
+# User Query
+{{ query }}
+
+{% if use_sub_agent_references and sub_agent_referencing_instructions | length > 0 %}
+# Sub Agents Referencing Reminder
+{{ sub_agent_referencing_instructions }}
+{%- endif %}
+
+{%- if mcp_server_user_prompts and mcp_server_user_prompts|length > 0 %}
+# MCP Server Context
+{%- for server_prompt in mcp_server_user_prompts %}
+{{ server_prompt }}
+{%- endfor %}
+{%- endif %}