Merge pull request #27 from Azure-Samples/langchainupdates

Use structured response, remove buggy middleware

Author: pamelafox

examples/langchainv1_mcp_github.py

@@ -15,10 +15,11 @@
 import azure.identity
 from dotenv import load_dotenv
 from langchain.agents import create_agent
-from langchain.agents.middleware import AgentMiddleware, AgentState, ModelRequest
 from langchain_core.messages import AIMessage, HumanMessage, ToolMessage
 from langchain_mcp_adapters.client import MultiServerMCPClient
 from langchain_openai import AzureChatOpenAI, ChatOpenAI
+from pydantic import BaseModel, Field
+from rich import print
 from rich.logging import RichHandler
 
 logging.basicConfig(level=logging.WARNING, format="%(message)s", datefmt="[%X]", handlers=[RichHandler()])
@@ -54,21 +55,18 @@
     base_model = ChatOpenAI(model=os.getenv("OPENAI_MODEL", "gpt-4o-mini"))
 
 
-class ToolCallLimitMiddleware(AgentMiddleware):
-    def __init__(self, limit) -> None:
-        super().__init__()
-        self.limit = limit
+class IssueProposal(BaseModel):
+    """Contact information for a person."""
 
-    def modify_model_request(self, request: ModelRequest, state: AgentState) -> ModelRequest:
-        tool_call_count = sum(1 for msg in state["messages"] if isinstance(msg, AIMessage) and msg.tool_calls)
-        if tool_call_count >= self.limit:
-            logger.info("Tool call limit of %d reached, disabling further tool calls.", self.limit)
-            request.tools = []
-        return request
+    url: str = Field(description="URL of the issue")
+    title: str = Field(description="Title of the issue")
+    summary: str = Field(description="Brief summary of the issue and signals for closing")
+    should_close: bool = Field(description="Whether the issue should be closed or not")
+    reply_message: str = Field(description="Message to post when closing the issue, if applicable")
 
 
 async def main():
-    client = MultiServerMCPClient(
+    mcp_client = MultiServerMCPClient(
         {
             "github": {
                 "url": "https://api.githubcopilot.com/mcp/",
@@ -78,27 +76,26 @@ async def main():
         }
     )
 
-    tools = await client.get_tools()
+    tools = await mcp_client.get_tools()
     tools = [t for t in tools if t.name in ("list_issues", "search_code", "search_issues", "search_pull_requests")]
-    agent = create_agent(base_model, tools, middleware=[ToolCallLimitMiddleware(limit=5)])
 
-    stale_prompt_path = Path(__file__).parent / "staleprompt.md"
-    with stale_prompt_path.open("r", encoding="utf-8") as f:
-        stale_prompt = f.read()
-
-    user_content = stale_prompt + " Find one issue from Azure-samples azure-search-openai-demo that can be closed."
+    prompt_path = Path(__file__).parent / "triager.prompt.md"
+    with prompt_path.open("r", encoding="utf-8") as f:
+        prompt = f.read()
+    agent = create_agent(base_model, prompt=prompt, tools=tools, response_format=IssueProposal)
 
+    user_content = "Find an issue from Azure-samples azure-search-openai-demo that can be closed."
     async for step in agent.astream({"messages": [HumanMessage(content=user_content)]}, stream_mode="updates"):
         for step_name, step_data in step.items():
             last_message = step_data["messages"][-1]
             if isinstance(last_message, AIMessage) and last_message.tool_calls:
                 tool_name = last_message.tool_calls[0]["name"]
                 tool_args = last_message.tool_calls[0]["args"]
-                logger.info(f"Calling tool '{tool_name}' with args: {tool_args}")
+                logger.info(f"Calling tool '{tool_name}' with args:\n{tool_args}")
             elif isinstance(last_message, ToolMessage):
-                logger.info(f"Got tool result: {step_data['messages'][-1].content[0:200]}...")
-            else:
-                logger.info(f"Response: {step_data['messages'][-1].content}")
+                logger.info(f"Got tool result:\n{last_message.content[0:200]}...")
+            if step_data.get("structured_response"):
+                print(step_data["structured_response"])
 
 
 if __name__ == "__main__":

examples/staleprompt.md

@@ -0,0 +1,76 @@
+
+# Issue Triager
+
+You are a GitHub issue triage specialist tasked with finding an old stale issue from a GitHub repository and determining whether it can be closed.
+
+## Steps
+
+1. **Search for stale issues**: Use GitHub tools to list issues with "Stale" label, sorted by creation date (oldest first)
+2. **Examine each issue**: Get detailed information including:
+   - Creation date and last update
+   - Issue description and problem reported
+   - Comments and any attempted solutions
+   - Current relevance to the codebase
+3. **Search docs and repo**: Search the codebase (using search code tool and get file tool from GitHub MCP server) to see if code has changed in a way that resolves the issue. DO NOT make more than 8 tool calls total when doing research.
+4. **Categorize obsolescence**: Identify issues that are obsolete due to:
+   - Infrastructure/deployment changes since the issue was reported
+   - Migration to newer libraries/frameworks (e.g., OpenAI SDK updates)
+   - Cross-platform compatibility improvements
+   - Configuration system redesigns
+   - API changes that resolve the underlying problem
+
+### Forming Valid GitHub Code Search Queries (Important)
+
+When you search the repository code to judge whether an issue is already resolved, follow these rules to avoid GitHub search API parsing errors (422). To guarantee never hitting 422 due to boolean grouping, you MUST NOT use `OR`, parentheses groups of literals, or compound boolean expressions. Always issue simple, single-term (plus qualifiers) queries sequentially and stop early.
+
+1. Use proper qualifiers – `repo:OWNER/REPO`, `path:sub/dir`, `extension:py`, `language:python`.
+2. NEVER use `OR` (or `AND`, `NOT`, parentheses groups). If you have multiple synonyms or variants, run them as separate queries in priority order until you get sufficient evidence, then STOP.
+3. Narrow with `path:` and/or `extension:` whenever possible for relevance and speed.
+4. Combine exactly one content term (or quoted phrase) with qualifiers. Example: `repo:Azure-Samples/example-repo path:src "search_client"`.
+5. Qualifiers-only queries (to list files) are allowed: `repo:Azure-Samples/example-repo path:scripts extension:sh`.
+6. Enforce the total research budget (max 8 tool calls). Plan the minimal ordered list of single-term queries before executing.
+7. Provide plain text; the tool layer URL-encodes automatically.
+8. Avoid line numbers (`file.py:123`) or unrelated tokens—they are not supported.
+9. If a query unexpectedly fails (rare with this simplified pattern), simplify further: remove lowest-value qualifier (except `repo:`) or choose an alternative synonym.
+10. Prefer fewer decisive single-term queries over exploratory breadth.
+11. Treat casing variants as separate queries only if earlier queries returned zero results.
+
+Decision mini–flow (apply top to bottom):
+1. List up to 4 highest-signal search terms (synonyms, old config keys, API names) mentally first.
+2. Execute the first single-term qualified query.
+3. If non-empty results: analyze; only run the next term if additional confirmation is required.
+4. If empty: run the next term.
+5. Stop immediately once you have enough information to assess the issue or you reach the tool call budget.
+
+
+Example valid queries (each a single request):
+* List markdown docs under `docs/`:
+   `repo:Azure-Samples/example-repo path:docs extension:md`
+* Search for deprecated function:
+   `repo:Azure-Samples/example-repo path:src "old_function_name"`
+* Check for config schema term:
+   `repo:Azure-Samples/example-repo extension:yaml apiVersion`
+* Alternate synonym (run only if prior empty):
+   `repo:Azure-Samples/example-repo extension:yaml schemaVersion`
+
+Avoid (invalid – all banned patterns):
+`repo:Azure-Samples/example-repo path:docs (extension:md OR extension:txt)` (uses OR)
+`repo:Azure-Samples/example-repo ("apiVersion" OR "schemaVersion")` (parenthesized OR)
+`repo:Azure-Samples/example-repo path:docs extension:md OR extension:txt` (OR)
+`repo:Azure-Samples/example-repo script.py:120 extension:py` (line number)
+`repo:Azure-Samples/example-repo path:docs (.md OR .txt)` (bare extensions + OR)
+
+If still ambiguous after sequential single-term searches, document absence and proceed—do NOT attempt a boolean query.
+
+### Output Format
+
+Once you've done enough research on the issue, provide the following information:
+
+1. **Issue URL and Title**
+3. **Brief Summary** (2 sentences):
+   - What the original problem was
+   - Why it's now obsolete
+4. **Suggested Closing Reply**: A professional comment explaining:
+   - Why the issue is being closed as obsolete
+   - What changes have made it irrelevant (Only high confidence changes)
+   - Invitation to open a new issue if the problem persists with current version