@microsoft/m365-copilot-eval 1.4.0-preview.1 → 1.6.0-preview.1

package/src/clients/cli/result_writer.py

@@ -0,0 +1,488 @@
+"""Output formatting, score conversion, and result writing."""
+
+import csv
+import json
+import os
+import sys
+import webbrowser
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+
+from cli_logging.cli_logger import emit_structured_log
+from cli_logging.logging_utils import Operation
+from common import (
+    DEFAULT_PASS_THRESHOLD,
+    RELEVANCE,
+    COHERENCE,
+    GROUNDEDNESS,
+    SIMILARITY,
+    TOOL_CALL_ACCURACY,
+    CITATIONS,
+    EXACT_MATCH,
+    PARTIAL_MATCH,
+    METRIC_IDS,
+    STATUS_PASS,
+    STATUS_FAIL,
+    STATUS_ERROR,
+    STATUS_PARTIAL,
+    STATUS_UNKNOWN,
+    pascal_case_to_title,
+    RunConfig,
+)
+from generate_report import generate_html_report, calculate_aggregate_statistics
+from schema_handler import SchemaVersionManager
+
+
+def write_results_to_html(results: List[Dict], output_file: str,
+                          agent_name: Optional[str] = None, agent_id: Optional[str] = None,
+                          cli_version: Optional[str] = None):
+    """Write results to HTML file using generate_html_report from generate_report.py."""
+    try:
+        html = generate_html_report(results, agent_name=agent_name, agent_id=agent_id,
+                                    cli_version=cli_version)
+        os.makedirs(os.path.dirname(os.path.abspath(output_file)), exist_ok=True)
+        with open(output_file, 'w', encoding='utf-8') as f:
+            f.write(html)
+        emit_structured_log("info", f"HTML report saved to {output_file}", operation=Operation.WRITE_OUTPUT)
+    except Exception as e:
+        emit_structured_log("error", f"Error writing to HTML file: {e}", operation=Operation.WRITE_OUTPUT)
+        sys.exit(1)
+
+
+def write_results_to_console(results, agent_name: Optional[str] = None,
+                             agent_id: Optional[str] = None,
+                             cli_version: Optional[str] = None):
+    """Write the response to console."""
+    # ANSI color codes
+    BOLD = '\033[1m'
+    BLUE = '\033[94m'
+    GREEN = '\033[92m'
+    YELLOW = '\033[93m'
+    CYAN = '\033[96m'
+    MAGENTA = '\033[95m'
+    ORANGE = '\033[38;5;208m'
+    RED = '\033[91m'
+    RESET = '\033[0m'
+
+    def _print_evaluated_item(response: str, expected_response: str,
+                              evaluators_ran: List[str], item_results: Dict[str, Any],
+                              error: Optional[str] = None) -> None:
+        """Print the body of a single evaluated item (single-turn prompt or multi-turn turn).
+
+        The item header (Prompt X / Turn X) is printed by the caller; this helper
+        prints evaluators, response, expected response, error, and metrics.
+        """
+        if evaluators_ran:
+            print(f"{BOLD}{CYAN}Evaluators:{RESET} {', '.join(evaluators_ran)}")
+        if response:
+            print(f"{BOLD}{CYAN}Response:{RESET} {response}")
+        if expected_response:
+            print(f"{BOLD}{YELLOW}Expected Response:{RESET} {expected_response}")
+        if error:
+            print(f"{BOLD}{RED}Error:{RESET} {error}")
+
+        for eval_name, v in item_results.items():
+            if v is None:
+                continue
+            display_name = pascal_case_to_title(eval_name)
+            if eval_name == RELEVANCE:
+                color = MAGENTA
+            elif eval_name == COHERENCE:
+                color = ORANGE
+            else:
+                color = BLUE
+            print(f"{BOLD}{color}{display_name}:{RESET} {json.dumps(v, indent=4)}")
+
+    # Show metadata
+    metadata_parts = []
+    if agent_name:
+        metadata_parts.append(f"Agent Name: {agent_name}")
+    if agent_id:
+        metadata_parts.append(f"Agent ID: {agent_id}")
+    if cli_version:
+        metadata_parts.append(f"CLI Version: {cli_version}")
+    if metadata_parts:
+        print(f"{BOLD}{CYAN}{' | '.join(metadata_parts)}{RESET}")
+        print()
+
+    aggregates = calculate_aggregate_statistics(results)
+    if aggregates:
+        total_items = aggregates[next(iter(aggregates))].get('total_prompts', len(results))
+        if total_items > 1:
+            print(f"{BOLD}{BLUE}Aggregate Statistics ({total_items} prompts):{RESET}")
+            print(f"{BLUE}{'=' * 60}{RESET}")
+
+            for metric_name, stats in aggregates.items():
+                pass_color = GREEN if stats['pass_rate'] >= 80 else YELLOW if stats['pass_rate'] >= 60 else RED
+                prompts_evaluated = stats.get('prompts_evaluated', stats['total_evaluated'])
+                total_prompts = stats.get('total_prompts', total_items)
+                print(f"{BOLD}{CYAN}{metric_name}:{RESET} ({prompts_evaluated}/{total_prompts} prompts)")
+                print(f"  Pass Rate: {pass_color}{stats['pass_rate']:.1f}%{RESET} ({stats['pass_count']}/{stats['total_evaluated']} passed)")
+                print(f"  Avg Score: {MAGENTA}{stats['avg_score']:.2f}{RESET}")
+                if stats.get('threshold') is not None:
+                    print(f"  Threshold: {YELLOW}{stats['threshold']}{RESET}")
+                print()
+
+            print(f"{BLUE}{'=' * 60}{RESET}")
+            print()
+
+    print(f"{BOLD}{BLUE}Individual Results:{RESET}")
+    print(f"{BLUE}{'=' * 50}{RESET}")
+    for i, result in enumerate(results, 1):
+        if result.get("type") == "multi_turn":
+            thread_name = result.get("name", "Unnamed Thread")
+            summary = result.get("summary", {})
+            status = summary.get("overall_status", STATUS_UNKNOWN)
+            status_color = GREEN if status == STATUS_PASS else YELLOW if status == STATUS_PARTIAL else RED
+
+            print(f"{BOLD}{MAGENTA}Thread {i}: {thread_name}{RESET}")
+            for t_idx, turn in enumerate(result.get("turns", []), 1):
+                turn_status = turn.get("status", STATUS_UNKNOWN)
+                turn_color = GREEN if turn_status == STATUS_PASS else RED if turn_status in (STATUS_FAIL, STATUS_ERROR) else YELLOW
+                print(f"{BOLD}{turn_color}Turn {t_idx}:{RESET} [{turn_status}] {turn.get('prompt', '')}")
+                _print_evaluated_item(
+                    response=turn.get("response", ""),
+                    expected_response=turn.get("expected_response", ""),
+                    evaluators_ran=turn.get("evaluators_ran", []),
+                    item_results=turn.get("results", {}),
+                    error=turn.get("error"),
+                )
+            print()
+            print(f"{BOLD}{MAGENTA}Thread {i} Summary:{RESET}")
+            print(f"  Status: {status_color}{status.upper()}{RESET}")
+            print(f"  Turns passed: {status_color}{summary.get('turns_passed', 0)}/{summary.get('turns_total', 0)}{RESET}")
+            print(f"{BLUE}{'-' * 30}{RESET}")
+        else:
+            print(f"{BOLD}{GREEN}Prompt {i}:{RESET} {result['prompt']}")
+            _print_evaluated_item(
+                response=result.get('response', ''),
+                expected_response=result.get('expected_response', ''),
+                evaluators_ran=result.get('evaluators_ran', []),
+                item_results=result.get('results', {}),
+                error=result.get('errorDetails'),
+            )
+            print(f"{BLUE}{'-' * 30}{RESET}")
+
+
+def extract_eval_score(data: dict, metric_id: str) -> Optional[Dict]:
+    """Extract an EvalScore object from a decorated metric dict.
+
+    Maps internal decorated-metric format to schema EvalScore:
+    {score, result, threshold} (required) + reason, evaluator (optional).
+    """
+    score_val = None
+    if metric_id in data and isinstance(data[metric_id], (int, float)):
+        score_val = data[metric_id]
+    if score_val is None:
+        return None
+
+    result = data.get("result")
+    if result not in (STATUS_PASS, STATUS_FAIL):
+        result = STATUS_PASS if score_val >= data.get("threshold", DEFAULT_PASS_THRESHOLD) else STATUS_FAIL
+
+    eval_score: Dict[str, Any] = {
+        "score": score_val,
+        "result": result,
+        "threshold": data.get("threshold", DEFAULT_PASS_THRESHOLD),
+    }
+    reason = data.get(f"{metric_id}_reason") or data.get("reason")
+    if reason:
+        eval_score["reason"] = reason
+    return eval_score
+
+
+def _convert_scores_to_schema(results_dict: Dict[str, Any]) -> Dict[str, Any]:
+    """Convert raw evaluator results to schema-compliant score objects.
+
+    Evaluator results in results_dict are dicts (from _decorate_metric) or
+    None when skipped/crashed. None values are omitted from output.
+    """
+    scores: Dict[str, Any] = {}
+
+    for eval_key, schema_key in [
+        (RELEVANCE, "relevance"),
+        (COHERENCE, "coherence"),
+        (GROUNDEDNESS, "groundedness"),
+        (SIMILARITY, "similarity"),
+        (TOOL_CALL_ACCURACY, "toolCallAccuracy"),
+    ]:
+        data = results_dict.get(eval_key)
+        if data is None:
+            continue
+        eval_score = extract_eval_score(data, METRIC_IDS[eval_key])
+        if eval_score:
+            scores[schema_key] = eval_score
+
+    data = results_dict.get(CITATIONS)
+    if data is not None:
+        count = data.get("citations", 0)
+        cit_result = data.get("result")
+        if cit_result not in (STATUS_PASS, STATUS_FAIL):
+            cit_result = STATUS_PASS if count >= data.get("threshold", 1) else STATUS_FAIL
+        citation_score: Dict[str, Any] = {
+            "count": count,
+            "result": cit_result,
+            "threshold": data.get("threshold", 1),
+        }
+        if "citation_format" in data:
+            citation_score["format"] = data["citation_format"]
+        scores["citations"] = citation_score
+
+    data = results_dict.get(EXACT_MATCH)
+    if data is not None:
+        is_match = data.get("exact_match", 0.0) == 1.0
+        scores["exactMatch"] = {
+            "match": is_match,
+            "result": data.get("result", STATUS_PASS if is_match else STATUS_FAIL),
+            "reason": data.get("exact_match_reason", ""),
+        }
+
+    data = results_dict.get(PARTIAL_MATCH)
+    if data is not None:
+        scores["partialMatch"] = {
+            "score": data.get("partial_match", 0.0),
+            "result": data.get("result", STATUS_FAIL),
+            "threshold": data.get("threshold", 0.5),
+            "reason": data.get("partial_match_reason", ""),
+        }
+
+    return scores
+
+
+def convert_result_to_eval_item(result: Dict) -> Dict:
+    """Convert an internal evaluation result dict to a schema-compliant EvalItem."""
+    item: Dict[str, Any] = {
+        "prompt": result["prompt"],
+        "response": result["response"],
+        "expected_response": result["expected_response"],
+    }
+
+    if "evaluators" in result:
+        item["evaluators"] = result["evaluators"]
+    if "evaluators_mode" in result:
+        item["evaluators_mode"] = result["evaluators_mode"]
+
+    scores = _convert_scores_to_schema(result.get("results", {}))
+    if scores:
+        item["scores"] = scores
+
+    return item
+
+
+def convert_thread_result_to_output(thread_result: Dict) -> Dict:
+    """Convert a multi-turn thread result to the output format."""
+    output_turns = []
+    for turn in thread_result.get("turns", []):
+        output_turn: Dict[str, Any] = {"prompt": turn.get("prompt", "")}
+        if "expected_response" in turn:
+            output_turn["expected_response"] = turn["expected_response"]
+        if "response" in turn:
+            output_turn["response"] = turn["response"]
+        if "status" in turn:
+            output_turn["status"] = turn["status"]
+        if "error" in turn:
+            output_turn["error"] = turn["error"]
+        if "evaluators" in turn:
+            output_turn["evaluators"] = turn["evaluators"]
+        if "evaluators_mode" in turn:
+            output_turn["evaluators_mode"] = turn["evaluators_mode"]
+
+        scores = _convert_scores_to_schema(turn.get("results", {}))
+        if scores:
+            output_turn["scores"] = scores
+
+        output_turns.append(output_turn)
+
+    output: Dict[str, Any] = {}
+    if thread_result.get("name"):
+        output["name"] = thread_result["name"]
+    if thread_result.get("description"):
+        output["description"] = thread_result["description"]
+    if thread_result.get("conversation_id"):
+        output["conversation_id"] = thread_result["conversation_id"]
+    output["turns"] = output_turns
+    if thread_result.get("summary"):
+        output["summary"] = thread_result["summary"]
+
+    return output
+
+
+def convert_result_to_output_item(result: Dict) -> Dict:
+    """Convert an internal result dict to an output item. Routes by type."""
+    if result.get("type") == "multi_turn":
+        return convert_thread_result_to_output(result)
+    return convert_result_to_eval_item(result)
+
+
+def write_results_to_json(results: List[Dict], output_file: str, agent_id: Optional[str] = None,
+                          default_evaluators: Optional[Dict[str, Any]] = None,
+                          agent_name: Optional[str] = None,
+                          cli_version: Optional[str] = None):
+    """Write results to a schema-compliant eval document JSON file.
+
+    Output follows the eval-document.schema.json format:
+    {schemaVersion, metadata, default_evaluators?, items: [EvalItem]}
+    """
+    try:
+        try:
+            current_version = SchemaVersionManager().get_current_version()
+        except Exception:
+            current_version = "1.0.0"
+
+        items = [convert_result_to_output_item(r) for r in results]
+
+        metadata: Dict[str, Any] = {
+            "evaluatedAt": datetime.now(timezone.utc).isoformat(),
+        }
+        if agent_id:
+            metadata["agentId"] = agent_id
+        if agent_name:
+            metadata["agentName"] = agent_name
+        if cli_version:
+            metadata["cliVersion"] = cli_version
+
+        output_data: Dict[str, Any] = {
+            "schemaVersion": current_version,
+            "metadata": metadata,
+        }
+
+        if default_evaluators is not None:
+            output_data["default_evaluators"] = default_evaluators
+
+        output_data["items"] = items
+
+        os.makedirs(os.path.dirname(os.path.abspath(output_file)), exist_ok=True)
+        with open(output_file, 'w', encoding='utf-8') as f:
+            json.dump(output_data, f, indent=2, ensure_ascii=False)
+        emit_structured_log("info", f"Results saved to {output_file}", operation=Operation.WRITE_OUTPUT)
+    except Exception as e:
+        emit_structured_log("error", f"Error writing to JSON file: {e}", operation=Operation.WRITE_OUTPUT)
+        sys.exit(1)
+
+
+def _results_to_csv_json(results_dict: Dict) -> str:
+    """Serialize evaluator results dict to a CSV-safe JSON string.
+
+    Skips None (crashed/skipped evaluators). Results are dicts produced
+    by _decorate_metric.
+    """
+    if not results_dict:
+        return ""
+    non_null = {k: v for k, v in results_dict.items() if v is not None}
+    return json.dumps(non_null) if non_null else ""
+
+
+def write_results_to_csv(results: List[Dict], output_file: str,
+                         agent_name: Optional[str] = None, agent_id: Optional[str] = None,
+                         cli_version: Optional[str] = None):
+    """Write results to CSV file."""
+    try:
+        os.makedirs(os.path.dirname(os.path.abspath(output_file)), exist_ok=True)
+        with open(output_file, 'w', newline='', encoding='utf-8') as f:
+            if results:
+                metadata_parts = []
+                if agent_name:
+                    metadata_parts.append(f"Agent Name: {agent_name}")
+                if agent_id:
+                    metadata_parts.append(f"Agent ID: {agent_id}")
+                if cli_version:
+                    metadata_parts.append(f"CLI Version: {cli_version}")
+                if metadata_parts:
+                    f.write(f"# {' | '.join(metadata_parts)}\n")
+
+                aggregates = calculate_aggregate_statistics(results)
+                if aggregates:
+                    total_items = aggregates[next(iter(aggregates))].get('total_prompts', len(results))
+                    if total_items > 1:
+                        f.write("# AGGREGATE STATISTICS\n")
+                        f.write("Metric,Prompts Evaluated,Total Prompts,Pass Rate (%),Passed,Failed,Avg Score,Threshold\n")
+                        for metric_name, stats in aggregates.items():
+                            threshold_str = str(stats.get('threshold', 'N/A'))
+                            prompts_evaluated = stats.get('prompts_evaluated', stats['total_evaluated'])
+                            total_prompts = stats.get('total_prompts', total_items)
+                            f.write(f"{metric_name},{prompts_evaluated},{total_prompts},{stats['pass_rate']:.1f},{stats['pass_count']},{stats['fail_count']},{stats['avg_score']:.2f},{threshold_str}\n")
+                        f.write("\n# INDIVIDUAL RESULTS\n")
+
+                single_turn_rows = []
+                multi_turn_rows = []
+                for result in results:
+                    if result.get("type") == "multi_turn":
+                        thread_name = result.get("name", "")
+                        for turn_idx, turn in enumerate(result.get("turns", [])):
+                            multi_turn_rows.append({
+                                "thread_name": thread_name,
+                                "turn_index": turn_idx + 1,
+                                "prompt": turn.get("prompt", ""),
+                                "response": turn.get("response", ""),
+                                "expected_response": turn.get("expected_response", ""),
+                                "status": turn.get("status", ""),
+                                "error": turn.get("error", ""),
+                                "scores": _results_to_csv_json(turn.get("results", {})),
+                            })
+                        summary = result.get("summary", {})
+                        multi_turn_rows.append({
+                            "thread_name": thread_name,
+                            "turn_index": "summary",
+                            "prompt": "",
+                            "response": "",
+                            "expected_response": "",
+                            "status": summary.get("overall_status", ""),
+                            "scores": f"{summary.get('turns_passed', 0)}/{summary.get('turns_total', 0)} turns passed",
+                        })
+                    else:
+                        exclude_keys = {'evaluators_ran', 'evaluators', 'evaluators_mode', '_enhanced_response', 'results'}
+                        row = {k: v for k, v in result.items() if k not in exclude_keys}
+                        if "results" in result:
+                            row["scores"] = _results_to_csv_json(result["results"])
+                        single_turn_rows.append(row)
+
+                if single_turn_rows:
+                    if multi_turn_rows:
+                        f.write("# SINGLE-TURN RESULTS\n")
+                    fieldnames = list(single_turn_rows[0].keys())
+                    for row in single_turn_rows:
+                        for k in row:
+                            if k not in fieldnames:
+                                fieldnames.append(k)
+                    writer = csv.DictWriter(f, fieldnames=fieldnames, extrasaction='ignore')
+                    writer.writeheader()
+                    writer.writerows(single_turn_rows)
+
+                if multi_turn_rows:
+                    if single_turn_rows:
+                        f.write("\n")
+                    f.write("# MULTI-TURN RESULTS\n")
+                    fieldnames = ["thread_name", "turn_index", "prompt", "response", "expected_response", "status", "error", "scores"]
+                    writer = csv.DictWriter(f, fieldnames=fieldnames, extrasaction='ignore')
+                    writer.writeheader()
+                    writer.writerows(multi_turn_rows)
+            emit_structured_log("info", f"Results saved to {output_file}", operation=Operation.WRITE_OUTPUT)
+    except Exception as e:
+        emit_structured_log("error", f"Error writing to CSV file: {e}", operation=Operation.WRITE_OUTPUT)
+        sys.exit(1)
+
+
+def output_results(results: List[Dict], config: RunConfig, default_evaluators: Optional[Dict[str, Any]] = None,
+                    agent_name: Optional[str] = None, cli_version: Optional[str] = None):
+    """Output results based on specified format."""
+    metadata_kwargs = dict(
+        agent_name=agent_name,
+        agent_id=config.m365_agent_id,
+        cli_version=cli_version,
+    )
+    if config.output:
+        output_lower = config.output.lower()
+        if output_lower.endswith('.json'):
+            write_results_to_json(results, config.output, default_evaluators=default_evaluators,
+                                  **metadata_kwargs)
+        elif output_lower.endswith('.csv'):
+            write_results_to_csv(results, config.output, **metadata_kwargs)
+        elif output_lower.endswith('.html'):
+            write_results_to_html(results, config.output, **metadata_kwargs)
+            abs_path = os.path.abspath(config.output)
+            webbrowser.open(f'file://{abs_path}')
+        else:
+            write_results_to_json(results, config.output, default_evaluators=default_evaluators,
+                                  **metadata_kwargs)
+    else:
+        write_results_to_console(results, **metadata_kwargs)

package/src/clients/node-js/bin/runevals.js

@@ -9,8 +9,13 @@ import { ensureVenv, executePythonCli } from '../lib/venv-manager.js';
 import { getCacheStats, clearCache, formatBytes } from '../lib/cache-utils.js';
 import { checkPackageExpiry } from '../lib/expiry-check.js';
 import { recordAcceptance, checkAcceptance } from '../lib/eula-manager.js';
-import { ProgressReporter } from '../lib/progress.js';
+import { ProgressReporter, isInteractiveTerminal } from '../lib/progress.js';
 import { _loadEnvFile as loadEnvFile, _loadUserEnvOverride } from '../lib/env-loader.js';
+import {
+  _handlePythonVersionMismatch,
+  _buildInitializationFailureLines,
+  _promptForContinueWithMismatch,
+} from '../lib/version-check.js';
 import { normalizeAgentId } from '../lib/agent-id.js';
 
 // Check package expiry (exits if expired, warns if close to expiry)
@@ -38,10 +43,9 @@ const REQUIREMENTS_FILE = path.join(PYTHON_CLI_DIR, 'requirements.txt');
  */
 async function setDefaultEnvironmentConstants() {
   const config = (await import('../config/default.js')).default;
-  process.env.M365_EVAL_CLIENT_ID = config.copilotApi.m365EvalClientId;
-  process.env.COPILOT_API_ENDPOINT = config.copilotApi.copilotApiEndpoint;
-  process.env.COPILOT_SCOPES = config.copilotApi.copilotScopes;
-  process.env.X_SCENARIO_HEADER = config.copilotApi.scenarioHeader;
+  process.env.WORK_IQ_A2A_ENDPOINT = config.workIq.a2aEndpoint;
+  process.env.WORK_IQ_A2A_CLIENT_ID = config.workIq.a2aClientId;
+  process.env.WORK_IQ_A2A_SCOPES = config.workIq.a2aScopes;
 }
 
 /**
@@ -131,10 +135,26 @@ async function initializePythonEnvironment(verbose = false, quiet = false) {
 
   try {
     // Step 1: Ensure Python runtime is available (handles download + extract phases)
-    await ensurePythonRuntime(verbose, onProgress);
+    const runtime = await ensurePythonRuntime(verbose, onProgress);
+
+    // Step 2: Handle version mismatch from PYTHON_PATH fallback.
+    // The decision tree (EOL block, interactive prompt, non-interactive
+    // auto-reject) lives in _handlePythonVersionMismatch so it is
+    // unit-testable without spawning the CLI; we only own the readline
+    // wiring and the actual process.exit here.
+    const mismatch = await _handlePythonVersionMismatch({
+      runtime,
+      isInteractive: isInteractiveTerminal(),
+      promptForContinue: _promptForContinueWithMismatch,
+      warn: (msg) => console.warn(msg),
+      error: (msg) => console.error(msg),
+    });
+    if (mismatch.shouldExit) {
+      process.exit(mismatch.exitCode ?? 1);
+    }
 
-    // Step 2: Ensure venv with dependencies is set up (handles venv + deps phases)
-    await ensureVenv(REQUIREMENTS_FILE, verbose, onProgress);
+    // Step 3: Ensure venv with dependencies is set up (handles venv + deps phases)
+    await ensureVenv(REQUIREMENTS_FILE, verbose, onProgress, runtime.pythonPath);
 
     // Show completion summary
     reporter.complete();
@@ -145,11 +165,12 @@ async function initializePythonEnvironment(verbose = false, quiet = false) {
       console.error('\nFull error:', error);
     }
 
-    console.error('\nTroubleshooting:');
-    console.error('  - Check your internet connection');
-    console.error('  - If behind a proxy, set HTTP_PROXY/HTTPS_PROXY environment variables');
-    console.error('  - For SSL issues, set NODE_EXTRA_CA_CERTS or PIP_CERT');
-    console.error('  - Run with --log-level debug for detailed output');
+    for (const line of _buildInitializationFailureLines({
+      error,
+      platform: process.platform,
+    })) {
+      console.error(line);
+    }
 
     process.exit(1);
   }

package/src/clients/node-js/config/default.js

@@ -2,25 +2,22 @@
  * Build-time injected default values
  * DO NOT EDIT - This file is auto-generated during build.
  *
- * Generated: 2026-04-22T20:44:41.713Z
+ * Generated: 2026-05-07T22:53:22.056Z
  *
  * @copyright Microsoft Corporation. All rights reserved.
  * @license MIT
  */
 
 export default {
-  copilotApi: {
-    /** Microsoft M365 Evaluation Client ID  */
-    m365EvalClientId: "c678803a-d8e9-4d67-849c-3a8b2d7ba5d3",
+  workIq: {
+    /** Work IQ A2A Endpoint */
+    a2aEndpoint: "https://graph.microsoft.com/rp/workiq",
 
-    /** Copilot OAuth Scopes */
-    copilotScopes: "https://substrate.office.com/sydney/.default",
+    /** Work IQ A2A Client ID */
+    a2aClientId: "ba081686-5d24-4bc6-a0d6-d034ecffed87",
 
-    /** Copilot API Endpoint */
-    copilotApiEndpoint: "https://substrate.office.com/m365Copilot",
-
-    /** Scenario Header for Copilot API */
-    scenarioHeader: "agenticevaluation"
+    /** Work IQ A2A OAuth Scopes */
+    a2aScopes: "Sites.Read.All Mail.Read People.Read.All OnlineMeetingTranscript.Read.All Chat.Read ChannelMessage.Read.All ExternalItem.Read.All"
   },
   eula: {
     /** EULA version string for acceptance tracking */

package/src/clients/node-js/lib/env-loader.js

@@ -9,10 +9,9 @@ import path from 'path';
 
 // Keys that cannot be overridden from .env files (baked in via default.js config)
 const PROTECTED_KEYS = [
-  'M365_EVAL_CLIENT_ID',
-  'COPILOT_API_ENDPOINT',
-  'COPILOT_SCOPES',
-  'X_SCENARIO_HEADER',
+  'WORK_IQ_A2A_ENDPOINT',
+  'WORK_IQ_A2A_CLIENT_ID',
+  'WORK_IQ_A2A_SCOPES',
 ];
 
 // Aliases resolved into M365_AGENT_ID (first match wins)