BUILD YOUR ENTERPRISE
DRUG LAUNCH SIMULATOR

You are a Principal AI Systems Architect building the Enterprise Drug Launch Strategy Simulator on Google ADK. TASK: Build the configuration and schema layer. Create 2 files COMPLETELY — no stubs, no placeholders. FILE 1: config/settings.py """Single source of truth for every external API constant used in this system.""" Define these EXACT constants (verified against live API documentation, do not alter): CTGOV_BASE_URL = "https://clinicaltrials.gov/api/v2/studies" CTGOV_TIMEOUT_SECONDS = 15 PUBMED_BASE_URL = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/" PUBMED_MIN_DELAY_NO_KEY = 0.34 # ≤3 req/sec ceiling without an API key PUBMED_MIN_DELAY_WITH_KEY = 0.1 # ≤10 req/sec ceiling with NCBI_API_KEY set WORLD_BANK_BASE_URL = "https://api.worldbank.org/v2/country/{country_codes}/indicator/{indicator}" WB_INDICATOR_GDP = "NY.GDP.MKTP.CD" WB_INDICATOR_GDP_PER_CAPITA = "NY.GDP.PCAP.CD" WB_INDICATOR_POPULATION = "SP.POP.TOTL" WB_INDICATOR_HEALTH_EXP_PCT_GDP = "SH.XPD.CHEX.GD.ZS" WB_INDICATOR_HEALTH_EXP_PER_CAPITA = "SH.XPD.CHEX.PC.CD" WHO_GHO_BASE_URL = "https://ghoapi.azureedge.net/api/{indicator_code}" WHO_GHO_INDICATOR_SEARCH_URL = "https://ghoapi.azureedge.net/api/Indicator" GOOGLE_NEWS_RSS_BASE = "https://news.google.com/rss/search" FDA_PRESS_RELEASE_RSS = "https://www.fda.gov/about-fda/contact-fda/stay-informed/rss-feeds/press-releases/rss.xml" RSS_MIN_DELAY_SECONDS = 2.0 OPENFDA_LABEL_URL = "https://api.fda.gov/drug/label.json" OPENFDA_EVENT_URL = "https://api.fda.gov/drug/event.json" OPENFDA_MIN_DELAY_SECONDS = 0.25 # ≤4 req/sec, safely under the 240/min no-key ceiling CROSSREF_BASE_URL = "https://api.crossref.org/works" OPENALEX_BASE_URL = "https://api.openalex.org/works" Also load from environment (use python-dotenv, load_dotenv() at module top): - GOOGLE_API_KEY (required, raise a clear error at startup if missing) - NCBI_API_KEY (optional, default None) - OPENFDA_API_KEY (optional, default None) - USE_CROSSREF_ENRICHMENT (optional bool, default False, parse from string "true"/"false") A small static ISO3-code → country-name dict for at least these 12 countries (WHO GHO returns ISO3 codes, not names): IND, BRA, IDN, NGA, MEX, VNM, ZAF, EGY, PHL, PAK, BGD, TUR FILE 2: schemas/tool_response.py """The contract every one of the 8 tool functions must return.""" Use a Python dataclass: from dataclasses import dataclass, field from typing import Any, Literal @dataclass class ToolResponse: status: Literal["success", "empty", "error"] data: list[dict[str, Any]] = field(default_factory=list) source: str = "" error_message: str | None = None def to_dict(self) -> dict: return { "status": self.status, "data": self.data, "source": self.source, "error_message": self.error_message, } CRITICAL RULES: - Every tool function built in Phase 3 returns ToolResponse(...).to_dict() — no exceptions, no naked dicts of differing shape. - "empty" means the API call succeeded but returned zero matching records (a VALID, common, meaningful outcome for a novel pre-approval drug — never treat empty as an error). - "error" means the HTTP call itself failed (network, timeout, malformed response) — always include error_message. - NEVER hardcode a base URL, indicator code, or RSS feed URL inside any tool or agent file written in later phases — everything imports from config.settings.

You are a Principal AI Systems Architect. You think in terms of: what are the three ways this API call fails (network, rate-limit, empty-result-set), and does my function return a typed, non-crashing response in all three cases? TASK: Build 2 tool functions used by the Scientific Intelligence agent later. Both import ToolResponse from schemas.tool_response and constants from config.settings. Real, working HTTP calls — zero mocks, zero "# TODO: implement." FILE 1: tools/clinical_trials.py def search_clinical_trials(condition: str, intervention: str, phase: str = "", status: str = "", max_results: int = 50) -> dict: - Google-style docstring (ADK surfaces this to the LLM as the tool's calling contract — be precise, not vague) - Build params dict: query.cond=condition, query.intr=intervention, pageSize=min(max_results,1000), format=json - If phase: add filter.phase. If status: add filter.overallStatus. - GET request to CTGOV_BASE_URL with CTGOV_TIMEOUT_SECONDS timeout, wrapped in try/except requests.exceptions.RequestException - Parse payload["studies"] — if empty list, return ToolResponse(status="empty", source="clinicaltrials.gov").to_dict() - Else extract per study: nctId, briefTitle, overallStatus, phases (list), leadSponsor name, hasResults — from protocolSection.identificationModule / statusModule / designModule / sponsorCollaboratorsModule - Return ToolResponse(status="success", data=records, source="clinicaltrials.gov").to_dict() - On exception: return ToolResponse(status="error", source="clinicaltrials.gov", error_message=str(e)).to_dict() FILE 2: tools/pubmed.py def search_pubmed_literature(query_terms: str, max_results: int = 30) -> dict: - Respect rate limit: time.sleep(PUBMED_MIN_DELAY_WITH_KEY if NCBI_API_KEY else PUBMED_MIN_DELAY_NO_KEY) before EACH of the two calls below - STEP 1 (ESearch): GET PUBMED_BASE_URL + "esearch.fcgi" with db=pubmed, term=query_terms, retmax=max_results, sort=date, retmode=json, api_key=NCBI_API_KEY if set - Parse response["esearchresult"]["idlist"] — cast count via int(response["esearchresult"]["count"]) - If idlist is empty: return ToolResponse(status="empty", source="pubmed").to_dict() — do NOT proceed to step 2 - STEP 2 (ESummary): GET PUBMED_BASE_URL + "esummary.fcgi" with db=pubmed, id=",".join(idlist), retmode=json - Iterate over result["uids"] (NOT result.keys() — "uids" is itself a key you must skip) - For each uid build: {pmid, title, pubdate, journal, first_author} from result[uid] - Return ToolResponse(status="success", data=records, source="pubmed").to_dict() - Wrap BOTH steps in one try/except — any exception anywhere returns ToolResponse(status="error", source="pubmed", error_message=str(e)).to_dict() CRITICAL RULES: - NEVER raise an uncaught exception from either function - NEVER treat an empty result set as an error — it's the EXPECTED case for a novel, not-yet-studied drug candidate - NEVER skip PubMed's ESearch step "to save a call" — ESummary requires PMIDs obtained from ESearch first, this is architecturally required, not optional - Docstrings must be precise enough that an LLM calling this tool knows exactly what arguments to pass

You are a Principal AI Systems Architect building the Enterprise Drug Launch Strategy Simulator. TASK: Build 2 tool functions for the Market Intelligence agent. Real HTTP calls, ToolResponse contract, full error handling. FILE 1: tools/world_bank.py def get_market_indicators(country_codes: list[str], indicators: list[str] = None) -> dict: - Default indicators to [WB_INDICATOR_GDP, WB_INDICATOR_GDP_PER_CAPITA, WB_INDICATOR_POPULATION, WB_INDICATOR_HEALTH_EXP_PCT_GDP] if None - For EACH indicator (loop indicators, but semicolon-join ALL country_codes into ONE request per indicator — never loop per-country): - url = WORLD_BANK_BASE_URL.format(country_codes=";".join(country_codes), indicator=indicator) - GET with params format=json, mrv=1 (most recent value) - Response is a list: response[0] is metadata, response[1] is the data array (or None if zero results — World Bank can return [metadata, None]) - If response[1] is None or empty: skip this indicator, continue the loop (not an error, just no data for that indicator/country combo) - For each row in response[1] where row["value"] is not None: append {country: row["country"]["value"], country_code: row["countryiso3code"], indicator: row["indicator"]["value"], indicator_code: indicator, year: row["date"], value: row["value"]} - If ALL indicators returned nothing: return ToolResponse(status="empty", source="worldbank.org").to_dict() - Else: return ToolResponse(status="success", data=all_records, source="worldbank.org").to_dict() - Wrap each HTTP call in try/except — on any RequestException, return ToolResponse(status="error", source="worldbank.org", error_message=str(e)).to_dict() immediately (don't silently swallow it and return partial empty success) FILE 2: tools/who_gho.py def get_disease_burden(disease_keyword: str, country_codes_iso3: list[str]) -> dict: - STEP 1: GET WHO_GHO_INDICATOR_SEARCH_URL with $filter=contains(IndicatorName,'{disease_keyword}') to resolve candidate indicator codes - If zero indicators found: return ToolResponse(status="empty", source="who_gho", error_message=f"No GHO indicator found for '{disease_keyword}'").to_dict() - Pick the first matching IndicatorCode (or let the caller pass a more specific keyword if results are too broad) - STEP 2: GET WHO_GHO_BASE_URL.format(indicator_code=resolved_code) with $filter querying SpatialDim in country_codes_iso3 and a recent date range - Parse response["value"] — for each row build {country_iso3: row["SpatialDim"], country_name: ISO3_TO_NAME.get(row["SpatialDim"], row["SpatialDim"]), year: row["TimeDim"], value: row["NumericValue"], indicator: disease_keyword} - If value array is empty: return ToolResponse(status="empty", source="who_gho").to_dict() - Return ToolResponse(status="success", data=records, source="who_gho").to_dict() - On exception: return ToolResponse(status="error", source="who_gho", error_message=str(e)).to_dict() CRITICAL RULES: - NEVER treat World Bank's response[0] (metadata) as the data — always unpack response[1] - NEVER loop one-country-per-World-Bank-call — semicolon-join them into a single request - NEVER guess a WHO GHO indicator code — resolve it by name search first, every time - Filter out null "value" fields before returning records — do not pass nulls downstream

You are a Principal AI Systems Architect building the Enterprise Drug Launch Strategy Simulator. TASK: Build ONE generic RSS tool function. This single function will be passed into BOTH the Competitive Intelligence agent (Google News) and the Regulatory Intelligence agent (FDA press releases) later — do not write two separate parsers. FILE: tools/rss_reader.py """Generic RSS feed reader using feedparser — serves Google News and FDA RSS alike.""" def fetch_rss(feed_url: str, max_items: int = 15) -> dict: - Import feedparser - time.sleep(RSS_MIN_DELAY_SECONDS) before parsing (self-throttle, these are unofficial-rate-limit public feeds) - parsed = feedparser.parse(feed_url) - Check parsed.bozo: if 1, log a warning (use Python's logging module) but DO NOT raise — continue to use parsed.entries anyway - If not parsed.entries: return ToolResponse(status="empty", source=feed_url).to_dict() - For each entry in parsed.entries[:max_items]: build {title: entry.get("title",""), link: entry.get("link",""), published: entry.get("published", entry.get("updated","")), summary: strip_html_tags(entry.get("summary",""))} - strip_html_tags: a small helper using re.sub(r'<[^>]+>', '', text) to remove HTML tags from the summary field (Google News summaries are HTML-laden) - Return ToolResponse(status="success", data=records, source=feed_url).to_dict() - Wrap the ENTIRE function body in try/except — if feedparser itself throws (rare, but a dead URL or DNS failure can), return ToolResponse(status="error", source=feed_url, error_message=str(e)).to_dict() def build_google_news_query_url(query_terms: str) -> str: - URL-encode query_terms (use urllib.parse.quote) - Return f"{GOOGLE_NEWS_RSS_BASE}?q={encoded}&hl=en-US&gl=US&ceid=US:en" - This helper lets the Competitive Intelligence agent build a query URL from drug/indication terms without hand-assembling URL encoding itself CRITICAL RULES: - ONE function serves both Google News and FDA RSS — the feed_url parameter is what differs, not the parsing logic - NEVER raise on parsed.bozo == 1 — feedparser's leniency is a feature, not a bug, here - The FDA feed URL occasionally gets restructured by FDA — that's exactly why feed_url is a parameter, not hardcoded inside this function

You are a Principal AI Systems Architect building the Enterprise Drug Launch Strategy Simulator. TASK: Build the final tool file, THEN build the Gate 1 smoke test script that verifies all 8 tools before any agent is written. FILE 1: tools/openfda.py def search_drug_labels(drug_term: str, max_results: int = 5) -> dict: - GET OPENFDA_LABEL_URL with params: search=f'openfda.generic_name:"{drug_term}"', limit=max_results - time.sleep(OPENFDA_MIN_DELAY_SECONDS) before the call - CATCH requests.exceptions.HTTPError SPECIFICALLY: if e.response.status_code == 404, return ToolResponse(status="empty", source="openfda", error_message="No marketed precedent label found — novel/pre-approval candidate").to_dict() — this is the expected path for new candidates, not a failure - On success: for each result, extract {brand_name: result.get("openfda",{}).get("brand_name",[]), generic_name: result.get("openfda",{}).get("generic_name",[]), boxed_warning: result.get("boxed_warning", []), warnings: result.get("warnings", []), drug_interactions: result.get("drug_interactions", [])} — use .get() everywhere, boxed_warning is often ABSENT, never index directly - Return ToolResponse(status="success", data=records, source="openfda").to_dict() - Any other exception: return ToolResponse(status="error", source="openfda", error_message=str(e)).to_dict() def search_adverse_events(drug_term: str, max_results: int = 10) -> dict: - Same pattern, but GET OPENFDA_EVENT_URL with search=f'patient.drug.medicinalproduct:"{drug_term}"', limit=max_results, sort=receivedate:desc - Same 404-means-empty handling - Extract whatever reaction/seriousness fields are present per result, using .get() defensively FILE 2: tools/smoke_test_all.py — THIS IS GATE 1 """Run every tool function once with a real hardcoded scenario. ALL 8 must print PASS before Phase 4 begins.""" - Import all 8 tool functions - Define ONE hardcoded test scenario at the top: drug="semaglutide", condition="type 2 diabetes", countries=["IN","BR","ID"], news_query="semaglutide launch OR partnership" - For each tool, call it, print f"[{tool_name}] status={result['status']} source={result['source']}" and: - PASS if status is "success" or "empty" (both are valid, non-crashing outcomes) - FAIL if status is "error" (print the error_message) OR if calling the function raised an uncaught exception - At the end, print a summary: "X/8 PASS" — and exit with a non-zero code if any tool FAILed, so this can be used as a real CI gate, not just a visual check GATE 1 — RUN THIS NOW: python tools/smoke_test_all.py DO NOT PROCEED TO PHASE 4 UNTIL ALL 8 TOOLS PRINT PASS. If any tool fails, fix that tool in isolation — do not patch around it with a try/except that hides the real problem, and do not proceed with a "we'll fix it later" placeholder.

You are a Principal AI Systems Architect building the Enterprise Drug Launch Strategy Simulator on Google ADK (stable google-adk, LlmAgent class — not the experimental Workflow runtime). TASK: Build agents/market_agent.py — Agent 1 of 6. This agent calls real tools; do not let it answer from background knowledge instead of calling them. FILE: agents/market_agent.py from google.adk.agents import LlmAgent from tools.world_bank import get_market_indicators from tools.who_gho import get_disease_burden market_agent = LlmAgent( name="market_intelligence_agent", model="gemini-2.5-flash", description="Evaluates pharmaceutical market opportunity across candidate launch countries using World Bank economic data and WHO disease burden data.", instruction="""You are a pharmaceutical market intelligence analyst. Write the FULL instruction string with these exact requirements: - Explicitly direct the LLM to call get_market_indicators for the country list, THEN call get_disease_burden for the indication/disease - If a tool returns status "empty": explicitly state no data was available for that country/indicator combination — never invent a plausible-sounding number to fill the gap - If a tool returns status "error": note the data source was temporarily unavailable, proceed with whatever the OTHER tool returned - Require exactly these 4 output sections: (1) Market Size & Growth Potential per country, (2) Disease Burden Summary per country, (3) Priority Market Ranking 1-N with one-sentence rationale per country, (4) Market Attractiveness Score 0-100 per country with the three driving factors named explicitly for the top-ranked country - End the instruction with: "Be explicit and numeric. Never say 'the market looks attractive' without citing the specific GDP, health expenditure, or disease burden figure that justifies the claim." Close the LlmAgent definition with: tools=[get_market_indicators, get_disease_burden], output_key="market_intelligence_report", ) CRITICAL RULES: - output_key must be exactly "market_intelligence_report" — this is the state key 2 downstream agents will reference later, a typo here causes a SILENT template-resolution failure, not a crash - The instruction must contain an explicit, unambiguous directive to call each tool BY NAME — a vague instruction lets the LLM "answer from training knowledge" instead, which defeats the entire point of building this tool

You are a Principal AI Systems Architect building the Enterprise Drug Launch Strategy Simulator on Google ADK. TASK: Build agents/scientific_agent.py — Agent 2 of 6. from google.adk.agents import LlmAgent from tools.clinical_trials import search_clinical_trials from tools.pubmed import search_pubmed_literature scientific_agent = LlmAgent( name="scientific_intelligence_agent", model="gemini-2.5-flash", description="Assesses scientific and clinical maturity of a drug candidate using ClinicalTrials.gov and PubMed data.", instruction="""You are a pharmaceutical clinical/scientific intelligence analyst. Write the FULL instruction string requiring: - Call search_clinical_trials using the drug's mechanism/name as intervention and indication as condition, no phase filter first, then optionally a second call filtered to PHASE3 to assess late-stage maturity specifically - Call search_pubmed_literature combining drug name/mechanism and indication as query_terms - If either tool returns "empty": state plainly that no trials/publications were found — frame this as a meaningful finding (early-stage or novel mechanism), not a tool failure to apologize for - Require exactly these 4 output sections: (1) Clinical Trial Landscape — count by phase, sponsors, statuses, (2) Publication Trend Summary — volume, recency, growing-or-shrinking, (3) Scientific Maturity Score 0-100 justified by trial-phase distribution, (4) Innovation Signal — flag if sparse trials AND sparse publications suggests a novel mechanism vs. a crowded, well-studied one Close with: tools=[search_clinical_trials, search_pubmed_literature], output_key="scientific_intelligence_report", ) CRITICAL RULES: - output_key must be exactly "scientific_intelligence_report" - The instruction must make explicit that completed Phase 3 trials score HIGHER maturity than only-Phase-1 trials — give the LLM the actual weighting logic, don't leave it to guess

You are a Principal AI Systems Architect building the Enterprise Drug Launch Strategy Simulator on Google ADK. TASK: Build agents/competitor_agent.py — Agent 3 of 6. from google.adk.agents import LlmAgent from tools.rss_reader import fetch_rss competitor_agent = LlmAgent( name="competitive_intelligence_agent", model="gemini-2.5-flash", description="Monitors competitor launches, partnerships, and acquisitions via news and press release feeds.", instruction="""You are a pharmaceutical competitive intelligence analyst. Write the FULL instruction string requiring: - Call fetch_rss with a Google News RSS query URL built from the indication area plus terms like "launch", "partnership", "acquisition", "FDA approval" — show the agent the EXACT URL pattern to build: https://news.google.com/rss/search?q=<URL-encoded query>&hl=en-US&gl=US&ceid=US:en - If the tool returns "empty" or "error": state plainly that no recent competitive signal was found via this channel — do NOT fabricate competitor names or deals to fill the gap - Require exactly these 4 output sections: (1) Recent Competitive Activity — headlines with source/date, (2) Competitor Landscape Summary — group companies by what they're doing (launching/partnering/acquired/advancing trials), (3) SWOT positioning based ONLY on retrieved headlines plus market/scientific data passed via state, (4) Market Positioning Recommendation - End the instruction with an explicit honesty requirement: "If the news feed returns sparse or no results, explicitly flag that competitive intelligence from this run is limited and should be supplemented by paid intelligence tools before a final go/no-go decision — do not paper over a thin data return with confident-sounding generic claims." Close with: tools=[fetch_rss], output_key="competitive_intelligence_report", ) CRITICAL RULES: - output_key must be exactly "competitive_intelligence_report" - This agent must build its own query URL using the helper pattern from tools/rss_reader.py — the instruction should reference fetch_rss directly, not a separate "search news" abstraction that doesn't exist

You are a Principal AI Systems Architect building the Enterprise Drug Launch Strategy Simulator on Google ADK. TASK: Build agents/regulatory_agent.py — Agent 4 of 6 — THEN build the Gate 2 isolation test for all 4 intelligence agents. from google.adk.agents import LlmAgent from tools.openfda import search_drug_labels, search_adverse_events from tools.rss_reader import fetch_rss regulatory_agent = LlmAgent( name="regulatory_intelligence_agent", model="gemini-2.5-flash", description="Assesses regulatory readiness and safety landscape using openFDA and FDA RSS data.", instruction="""You are a pharmaceutical regulatory intelligence analyst. Write the FULL instruction string requiring: - Call search_drug_labels for the drug name or its drug class to find comparable approved-drug labels - Call search_adverse_events for the same term to check safety signal density in that drug class - Call fetch_rss with FDA_PRESS_RELEASE_RSS to check for recent regulatory actions - CRITICAL explicit instruction: "If search_drug_labels returns 'empty', this is EXPECTED and INFORMATIVE for a novel, not-yet-approved candidate — explicitly state 'no marketed precedent label found; this candidate would be a novel regulatory filing' rather than treating it as a failure." - Require exactly these 4 output sections: (1) Comparable Approved Products — labels found with boxed warnings if present, (2) Safety Signal Summary, (3) Recent Regulatory Activity from the FDA feed, (4) Regulatory Risk Rating Low/Medium/High WITH the specific factors driving the rating named explicitly Close with: tools=[search_drug_labels, search_adverse_events, fetch_rss], output_key="regulatory_intelligence_report", ) FILE 2: tests/test_agents_isolated.py — THIS IS GATE 2 """Run each of the 4 intelligence agents ALONE, print its raw output_key value.""" - Import Runner and InMemorySessionService from google.adk - For EACH of the 4 agents (market, scientific, competitor, regulatory): create an isolated Runner with InMemorySessionService, run ONE hardcoded test scenario (drug="semaglutide", indication="type 2 diabetes", countries=["India","Brazil","Indonesia"]) - Print the agent's final session.state[output_key] value in full - Manually-inspectable PASS criteria printed per agent: "Does this output contain REAL numbers/names traceable to a tool call, or generic LLM prose with no real data in it?" GATE 2 — RUN THIS NOW: python tests/test_agents_isolated.py DO NOT PROCEED TO PHASE 5 UNTIL: each of the 4 agents, run alone, produces non-empty, schema-conformant output that visibly contains real data threaded through from its tool calls — not generic invented prose. If Agent 1 returns text with no actual GDP numbers in it because the tool wasn't called, that is a FAIL even though no exception was thrown.

You are a Principal AI Systems Architect building the Enterprise Drug Launch Strategy Simulator on Google ADK. TASK: Build agents/commercial_agent.py — Agent 5 of 6. This agent has NO tools — pure reasoning over the 4 upstream reports. from google.adk.agents import LlmAgent commercial_agent = LlmAgent( name="commercial_strategy_agent", model="gemini-2.5-flash", description="Synthesizes market, scientific, competitive, and regulatory intelligence into a commercial launch strategy. Uses no external tools — pure reasoning over upstream agent outputs.", instruction="""You are a pharmaceutical commercial strategy lead. You have NO tools. Your job is pure synthesis and judgment over the four intelligence reports already gathered by upstream specialist agents, available to you as: Market Intelligence: {market_intelligence_report} Scientific Intelligence: {scientific_intelligence_report} Competitive Intelligence: {competitive_intelligence_report} Regulatory Intelligence: {regulatory_intelligence_report} Continue the instruction string requiring exactly these 5 output sections: 1. Launch Strategy Overview — sequencing recommendation drawing explicitly on the Market Intelligence ranking 2. Product Positioning — vs. competitors identified in Competitive Intelligence, using clinical evidence strength from Scientific Intelligence 3. Pricing Strategy Direction — explicitly: "do not invent a specific price point in absence of payer data; instead recommend a pricing APPROACH — e.g., value-based vs. reference pricing — justified by the disease burden and health-expenditure data in Market Intelligence" 4. Target Customer / Prescriber Profile 5. Commercial Risks — each one traceable to a specific fact from one of the four upstream reports, never a generic risk with no evidentiary anchor End the instruction with: "NEVER contradict a finding from an upstream report without explicitly flagging the contradiction and your reasoning for resolving it." Close with: tools=[], output_key="commercial_strategy_report", ) CRITICAL RULES: - The four {state_variable} names in the instruction string must be character-for-character identical to the output_key values from Phase 4 — copy-paste them, do not retype - tools=[] is intentional and correct — do NOT add tools to this agent, its entire value is disciplined reasoning over already-gathered evidence

You are a Principal AI Systems Architect building the Enterprise Drug Launch Strategy Simulator on Google ADK. TASK: Build agents/executive_agent.py — Agent 6 of 6, the FINAL agent in the pipeline. No tools. This produces the actual deliverable a board would read. from google.adk.agents import LlmAgent executive_agent = LlmAgent( name="executive_decision_agent", model="gemini-2.5-flash", description="Produces the final Executive Launch Dossier synthesizing all five upstream reports into a board-ready recommendation.", instruction="""You are presenting to the executive committee. You have NO tools. Synthesize ALL FIVE upstream reports, available to you as: Market Intelligence: {market_intelligence_report} Scientific Intelligence: {scientific_intelligence_report} Competitive Intelligence: {competitive_intelligence_report} Regulatory Intelligence: {regulatory_intelligence_report} Commercial Strategy: {commercial_strategy_report} Continue the instruction requiring this EXACT 8-section output structure, in this exact order: 1. Executive Summary (3-5 sentences: drug, headline recommendation, single most important reason why) 2. Market Opportunity Score [0-100] — justified by specific figures from Market Intelligence 3. SWOT Analysis — Strengths/Weaknesses/Opportunities/Threats, 2-4 bullets each, each traceable to a specific upstream finding 4. Launch Readiness Score [0-100] — weighted explicitly: scientific maturity 40%, regulatory risk 30%, competitive position 30%, show the weighted-component math, don't just assert a number 5. Recommended Launch Timeline — phase-gated, tied to clinical/regulatory milestones found upstream; if Phase 3 isn't complete yet, the timeline MUST reflect that realistically, not an aspirational date 6. Key Business Risks — top 5, ranked by severity, each traceable to a specific upstream fact 7. Success Probability [percentage]% — must correlate logically with Launch Readiness Score and Regulatory Risk Rating, with reasoning shown 8. Final Recommendation: [LAUNCH | DELAY | GATHER MORE EVIDENCE | DO NOT LAUNCH] Embed this EXACT decision rule in the instruction, verbatim, for the agent to apply and cite explicitly: - LAUNCH: Launch Readiness Score ≥ 70 AND Regulatory Risk is Low or Medium - GATHER MORE EVIDENCE: Scientific Maturity is low (early-phase trials only, sparse publications) but Market Opportunity is high — recommend specific additional evidence needed - DELAY: Regulatory Risk is High OR there is an unresolved Phase 3 trial outcome pending - DO NOT LAUNCH: Market Opportunity Score is very low AND no clear differentiation found in Competitive Intelligence - "State which rule applied and why, explicitly." Close with: tools=[], output_key="executive_launch_dossier", ) CRITICAL RULES: - All FIVE {state_variable} names must character-match the five output_key values from Phases 4 and 5a exactly - The decision rule must be applied explicitly and shown, not just asserted — a board reading this needs to see WHY a score crossed a threshold, not just the resulting label

You are a Principal AI Systems Architect building the Enterprise Drug Launch Strategy Simulator on Google ADK. TASK: Build agents/coordinator_agent.py — the final composition wiring all 6 agents into one pipeline. Then run a real end-to-end trace. from google.adk.agents import SequentialAgent, ParallelAgent from agents.market_agent import market_agent from agents.scientific_agent import scientific_agent from agents.competitor_agent import competitor_agent from agents.regulatory_agent import regulatory_agent from agents.commercial_agent import commercial_agent from agents.executive_agent import executive_agent # Agents 1-4 have no interdependencies on each other's outputs — run them concurrently. intelligence_gathering = ParallelAgent( name="intelligence_gathering_block", sub_agents=[market_agent, scientific_agent, competitor_agent, regulatory_agent], description="Runs the four independent intelligence-gathering specialist agents concurrently.", ) # The full pipeline: gather in parallel, then synthesize strictly in order. root_agent = SequentialAgent( name="drug_launch_strategy_coordinator", sub_agents=[intelligence_gathering, commercial_agent, executive_agent], description="End-to-end Enterprise Drug Launch Strategy Simulator pipeline: parallel intelligence gathering, followed by sequential commercial synthesis and executive decision synthesis.", ) CRITICAL: the variable MUST be named root_agent (not coordinator_agent) — ADK's adk run / adk web CLI discovery specifically looks for this exact name in the module. NEXT — build tests/test_end_to_end.py (Gate 3): - Run the full pipeline via the ADK Runner against ONE complete scenario: drug_name="Pharmara-GLP1X", mechanism="dual GLP-1/GIP receptor agonist", indication="type 2 diabetes and obesity", candidate_countries=["India","Brazil","Indonesia","Mexico","Nigeria"] - Print the final executive_launch_dossier output in full - Then MANUALLY trace at least 3 specific facts in that final output back to a specific tool call's data (e.g., a specific GDP figure, a specific NCT trial ID, a specific competitor headline) — confirm the pipeline isn't silently falling back to the LLM's own unverified background knowledge instead of the real tool data GATE 3 — RUN THIS NOW: adk run agents/coordinator_agent DO NOT PROCEED TO PHASE 7 UNTIL: the full end-to-end run produces a final executive output that visibly contains real numbers/names threaded through from Phase 3's tool calls — not generic LLM-invented content. If you can't trace at least 3 specific facts back to a specific tool call, something upstream is silently failing even though no exception fired.

You are a Principal AI Systems Architect finishing the Enterprise Drug Launch Strategy Simulator build on Google ADK. TASK: Harden the system, prove it generalizes, then ship it. FILE 1: main.py - CLI entry point that prompts for: drug_name, mechanism, indication, candidate_countries (comma-separated, accept common country names — not just ISO codes) - Reject empty drug_name or indication with a clear error message, re-prompt - Invoke the root_agent pipeline via ADK's Runner with the collected inputs - Print the final executive_launch_dossier to stdout AND save it to output/executive_dossier_<drug_name>_<timestamp>.md FILE 2: README.md - Setup instructions (pip install, .env configuration) - Run instructions: `adk run agents/coordinator_agent` (CLI) or `adk web agents/` (browser UI) or `python main.py` - An architecture diagram (ASCII or mermaid) showing the ParallelAgent → SequentialAgent flow - A note on the single required credential: GOOGLE_API_KEY only FILE 3: CHANGELOG.md - Document any deviation you had to make from the original API contracts during this build (e.g., if ClinicalTrials.gov or openFDA had drifted since this prompt was written) — the exact diff you found and how you adapted, so future maintainers know exactly where to look first GATE 4 — RUN THIS NOW WITH A DIFFERENT SCENARIO: Run the full pipeline again with a SECOND, DIFFERENT test case — different drug, different indication, different countries than Phase 6 used. For example: drug_name="Cardiozyme-7", mechanism="PCSK9 inhibitor", indication="hypercholesterolemia and cardiovascular risk reduction", candidate_countries=["South Africa","Philippines","Vietnam","Egypt","Turkey"] DO NOT PROCEED UNTIL: this second, independent scenario also runs end-to-end successfully and produces a complete, well-formed Executive Launch Dossier — this proves the system generalizes rather than being overfit to the one example used while building it. GATE 5 (OPTIONAL — only attempt if Gates 0-4 are ALL green): - Build tools/crossref_openalex.py behind the USE_CROSSREF_ENRICHMENT flag from config.settings — additive enrichment to scientific_agent only, never required for the core pipeline to function - OPTIONAL stretch: a simple Streamlit or Gradio front-end that calls the same coordinator_agent and renders the 8 dossier sections visually - Never sacrifice Gate 4 stability to rush this — if you're not fully confident in Gates 0-4, skip Gate 5 entirely and ship without it