artificial-intelligence-local 0.0.1b3046__py3-none-any.whl

artificial_intelligence_local/src/contact_agent.py

@@ -0,0 +1,6 @@
+"""Contacts agent (stub).
+
+Filled in PR4: wraps contact_local's get_phone_number_by_name as a Strands
+@tool (same pattern as the weather agent), routed through local Ollama.
+Answers "What's Tal's phone number?".
+"""

artificial_intelligence_local/src/strands_wrapper_generator.py

@@ -0,0 +1,239 @@
+"""Auto-generate read-only Strands agent wrappers for our *_local packages.
+
+Reads a ``*_local.py`` source file WITHOUT importing it -- so it works even
+when the target package cannot import without the :3000 auth server and a live
+DB -- finds the main class, and emits a ``<module>_strands.py`` file containing:
+
+  * a module docstring
+  * a ``_<factory>()`` helper returning a fresh instance of the class
+  * one ``<method>_strand`` twin per read-only method that:
+      - drops ``self``, keeps the exact param/return annotations,
+      - calls the same-named method on a fresh instance,
+      - stores the result in ``<method>_strand_result`` and returns it,
+      - carries a ``"Strand twin of <Class>.<method>."`` docstring
+
+Read-only selection rule: the method name starts with ``get_``, its first
+parameter is ``self``, it is not a ``get_test_*`` helper, not private, and not
+a @staticmethod/@classmethod. Only methods defined on the class itself are
+wrapped -- inherited getters from a base class are not.
+
+The emitted file is a draft: run it through the repo formatter (black/isort)
+and review before committing.
+
+Usage:
+    python -m strands_wrapper_generator <path/to/foo_local.py> [--out DIR]
+"""
+
+from __future__ import annotations
+
+import argparse
+import ast
+import os
+
+READ_PREFIXES = ("get_",)  # wrap read-only getters only
+
+_BUILTIN_NAMES = {
+    "int", "str", "float", "bool", "bytes", "dict", "list", "tuple", "set",
+    "frozenset", "object", "None", "any", "type", "complex", "bytearray",
+}
+
+
+def _pick_main_class(tree: ast.Module) -> ast.ClassDef:
+    """First top-level class in the file (the *_local classes are singletons)."""
+    classes = [n for n in tree.body if isinstance(n, ast.ClassDef)]
+    if not classes:
+        raise SystemExit("no top-level class found in source")
+    return classes[0]
+
+
+def _decorator_names(fn: ast.FunctionDef) -> set[str]:
+    names = set()
+    for d in fn.decorator_list:
+        if isinstance(d, ast.Name):
+            names.add(d.id)
+        elif isinstance(d, ast.Attribute):
+            names.add(d.attr)
+    return names
+
+
+def _first_param_is_self(fn: ast.FunctionDef) -> bool:
+    args = fn.args.posonlyargs + fn.args.args
+    return bool(args) and args[0].arg == "self"
+
+
+def _is_read_only_instance_method(fn: ast.stmt) -> bool:
+    if not isinstance(fn, ast.FunctionDef):
+        return False
+    name = fn.name
+    if name.startswith("_"):
+        return False
+    if name.startswith("get_test"):
+        return False
+    if not name.startswith(READ_PREFIXES):
+        return False
+    if _decorator_names(fn) & {"staticmethod", "classmethod"}:
+        return False
+    return _first_param_is_self(fn)
+
+
+def _factory_name(class_name: str) -> str:
+    """ContactsLocal -> _contacts  (strip 'Local', lowercase)."""
+    base = class_name[:-5] if class_name.endswith("Local") else class_name
+    return "_" + base.lower()
+
+
+def _params_without_self(fn: ast.FunctionDef) -> tuple[str, str]:
+    """Return (signature_params, call_args) reproduced from the AST.
+
+    signature_params: 'contact_id: int'  (self dropped, annotations kept)
+    call_args:        'contact_id'
+    """
+    a = fn.args
+    pos = a.posonlyargs + a.args
+    # drop leading self
+    pos = pos[1:] if pos and pos[0].arg == "self" else pos
+
+    defaults = a.defaults
+    n_defaults = len(defaults)
+    first_default = len(pos) - n_defaults
+
+    sig_parts: list[str] = []
+    call_parts: list[str] = []
+    for i, arg in enumerate(pos):
+        piece = arg.arg
+        if arg.annotation is not None:
+            piece += f": {ast.unparse(arg.annotation)}"
+        if i >= first_default:
+            piece += f" = {ast.unparse(defaults[i - first_default])}"
+        sig_parts.append(piece)
+        call_parts.append(arg.arg)
+
+    # keyword-only args (rare here, handled for robustness)
+    for arg, default in zip(a.kwonlyargs, a.kw_defaults):
+        piece = arg.arg
+        if arg.annotation is not None:
+            piece += f": {ast.unparse(arg.annotation)}"
+        if default is not None:
+            piece += f" = {ast.unparse(default)}"
+        sig_parts.append(piece)
+        call_parts.append(f"{arg.arg}={arg.arg}")
+
+    return ", ".join(sig_parts), ", ".join(call_parts)
+
+
+def _render_twin(fn: ast.FunctionDef, class_name: str, factory: str) -> str:
+    name = fn.name
+    sig, call = _params_without_self(fn)
+    ret = f" -> {ast.unparse(fn.returns)}" if fn.returns is not None else ""
+    result_var = f"{name}_strand_result"
+    return (
+        f"def {name}_strand({sig}){ret}:\n"
+        f'    """Strand twin of {class_name}.{name}."""\n'
+        f"    {result_var} = {factory}().{name}({call})\n"
+        f"    return {result_var}\n"
+    )
+
+
+def _import_map(tree: ast.Module) -> dict[str, str]:
+    """Map each top-level imported name -> the import statement that binds it."""
+    m: dict[str, str] = {}
+    for node in tree.body:
+        if isinstance(node, ast.ImportFrom):
+            mod = "." * (node.level or 0) + (node.module or "")
+            for a in node.names:
+                bound = a.asname or a.name
+                m[bound] = f"from {mod} import {a.name}" + (f" as {a.asname}" if a.asname else "")
+        elif isinstance(node, ast.Import):
+            for a in node.names:
+                bound = a.asname or a.name.split(".")[0]
+                m[bound] = f"import {a.name}" + (f" as {a.asname}" if a.asname else "")
+    return m
+
+
+def _names_in_annotations(methods: list[ast.FunctionDef]) -> set[str]:
+    """Every top-level name referenced by the wrapped methods' annotations."""
+    names: set[str] = set()
+    for fn in methods:
+        anns = [a.annotation for a in (fn.args.posonlyargs + fn.args.args + fn.args.kwonlyargs) if a.annotation]
+        if fn.returns is not None:
+            anns.append(fn.returns)
+        for ann in anns:
+            for n in ast.walk(ann):
+                if isinstance(n, ast.Name):
+                    names.add(n.id)
+                elif isinstance(n, ast.Attribute):
+                    root = n
+                    while isinstance(root, ast.Attribute):
+                        root = root.value
+                    if isinstance(root, ast.Name):
+                        names.add(root.id)
+    return names
+
+
+def generate(source_path: str) -> str:
+    """Return the source text of the ``*_strands.py`` wrapper for ``source_path``."""
+    with open(source_path, "r", encoding="utf-8") as f:
+        src = f.read()
+    tree = ast.parse(src)
+    cls = _pick_main_class(tree)
+    class_name = cls.name
+    module_name = os.path.splitext(os.path.basename(source_path))[0]  # e.g. contact_local
+    factory = _factory_name(class_name)
+
+    # dedupe by name, keeping the last definition (mirrors Python's own
+    # redefinition semantics; some sources define the same method twice).
+    by_name: dict[str, ast.FunctionDef] = {}
+    for n in cls.body:
+        if _is_read_only_instance_method(n):
+            by_name[n.name] = n
+    methods = list(by_name.values())
+
+    # carry over imports the wrapped annotations reference (e.g. typing.Dict)
+    imap = _import_map(tree)
+    extra_imports = sorted(
+        {imap[nm] for nm in _names_in_annotations(methods) if nm not in _BUILTIN_NAMES and nm in imap}
+    )
+
+    out: list[str] = []
+    out.append(
+        f'"""Read-only Strands agent wrapper over {class_name}.\n\n'
+        f'Each function here is a thin "_strand" twin of an existing {class_name}\n'
+        f"method: ``<method>_strand`` simply calls ``<method>`` and returns its\n"
+        f"result. No new business logic lives here -- all logic stays in\n"
+        f"{class_name}. These functions are what the local AI agent wires in as\n"
+        f"Strands tools.\n\n"
+        f"AUTO-GENERATED by strands_wrapper_generator.py -- do not edit by hand.\n"
+        f'"""\n'
+    )
+    import_lines = [f"from .{module_name} import {class_name}"] + extra_imports
+    out.append("\n".join(import_lines) + "\n")
+    out.append(
+        f"def {factory}() -> {class_name}:\n"
+        f'    """Return a fresh {class_name} instance to call existing methods on."""\n'
+        f"    return {class_name}()\n"
+    )
+    for fn in methods:
+        out.append(_render_twin(fn, class_name, factory))
+
+    return "\n\n".join(out) + "\n"
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    ap.add_argument("source", help="path to a *_local.py source file")
+    ap.add_argument("--out", default=None, help="dir to write <module>_strands.py; default = stdout")
+    args = ap.parse_args()
+
+    code = generate(args.source)
+    if args.out:
+        module_name = os.path.splitext(os.path.basename(args.source))[0]
+        dest = os.path.join(args.out, f"{module_name}_strands.py")
+        with open(dest, "w", encoding="utf-8") as f:
+            f.write(code)
+        print(f"wrote {dest}")
+    else:
+        print(code, end="")
+
+
+if __name__ == "__main__":
+    main()

artificial_intelligence_local/src/weather_agent.py

@@ -0,0 +1,212 @@
+"""Ollama weather agent.
+
+A local-first Strands weather agent that follows the tool-based pattern from the
+Strands samples repo (python/07-ux-demos/triage-agent weather server): the
+National Weather Service two-step (points -> forecast) lives inside a Python
+`get_forecast` tool, and a local Ollama model just decides the coordinates and
+phrases the result.
+
+Running the NWS calls in code -- instead of handing the model the generic
+`http_request` tool and asking it to build URLs and parse JSON itself -- makes
+small local models far more reliable: they only pick coordinates, call one tool,
+and summarize the answer.
+"""
+
+import os
+import sys
+
+import ollama
+import requests
+from dotenv import find_dotenv, load_dotenv
+from strands import Agent, tool
+from strands.models.ollama import OllamaModel
+
+# Load OLLAMA_* settings from a local .env.local1 file if one exists
+# (see .env.local1.example). find_dotenv searches up from the current working
+# directory, so this works whichever sub-directory you launch the agent from.
+load_dotenv(find_dotenv(".env.local1", usecwd=True))
+
+# Free US National Weather Service API. It requires a descriptive User-Agent;
+# requests without one can be rejected.
+NWS_API_BASE = "https://api.weather.gov"
+NWS_HEADERS = {
+    "User-Agent": "circlez-ai-local-weather-agent (contact: dev@circ.zone)",
+    "Accept": "application/geo+json",
+}
+
+
+@tool
+def get_forecast(latitude: float, longitude: float) -> str:
+    """Get the current weather forecast for a US location.
+
+    Args:
+        latitude: Latitude in decimal degrees (e.g. 47.6062 for Seattle).
+        longitude: Longitude in decimal degrees (e.g. -122.3321 for Seattle).
+
+    Returns:
+        A short human-readable forecast for the upcoming period, or a message
+        explaining that no forecast is available (e.g. the coordinates are
+        outside the US, which the NWS does not cover).
+    """
+    try:
+        points = requests.get(
+            f"{NWS_API_BASE}/points/{latitude},{longitude}",
+            headers=NWS_HEADERS,
+            timeout=10,
+        )
+        if points.status_code != 200:
+            return (
+                f"No weather data for {latitude},{longitude} -- the National "
+                "Weather Service only covers locations in the United States."
+            )
+        forecast_url = points.json()["properties"]["forecast"]
+
+        forecast = requests.get(forecast_url, headers=NWS_HEADERS, timeout=10)
+        forecast.raise_for_status()
+        period = forecast.json()["properties"]["periods"][0]
+    except (requests.RequestException, KeyError, IndexError) as error:
+        return f"Could not retrieve the forecast: {error}"
+
+    return (
+        f"{period['name']}: {period['temperature']}°{period['temperatureUnit']}, "
+        f"{period['shortForecast']} "
+        f"(wind {period['windSpeed']} {period['windDirection']})."
+    )
+
+
+WEATHER_SYSTEM_PROMPT = """You are a weather assistant for locations in the United States.
+
+You have one tool: get_forecast(latitude, longitude). To answer a weather question:
+1. Work out the latitude and longitude of the location from your own knowledge.
+2. Call get_forecast with those coordinates.
+3. Reply in ONE or TWO short sentences that state the temperature and the conditions.
+
+Rules -- follow them strictly:
+- Do NOT narrate your steps or say what you are "about to" do. Call the tool, then
+  give only the final answer.
+- If get_forecast says there is no data or that it could not retrieve the forecast,
+  tell the user you could not get weather for that location. Never invent a forecast.
+- If the location is not a real US place, say you cannot find it instead of guessing.
+"""
+
+def build_agent(model_id):
+    """Build the weather Agent backed by a local Ollama model.
+
+    Kept as a factory so the interactive picker can build the agent with the
+    model the user chose at startup, while imports/tests still get a ready-made
+    agent from the configured default (see ``weather_agent`` below).
+    """
+    model = OllamaModel(
+        host=os.getenv("OLLAMA_HOST", "http://localhost:11434"),
+        model_id=model_id,
+    )
+    return Agent(
+        model=model,
+        system_prompt=WEATHER_SYSTEM_PROMPT,
+        tools=[get_forecast],
+    )
+
+
+def available_ollama_models():
+    """Return the locally-pulled Ollama model ids, e.g. ``["qwen2.5:7b", ...]``.
+
+    Uses the Ollama Python client. Returns an empty list if Ollama is not
+    running or has no models pulled, so callers can fall back to the default.
+    """
+    try:
+        response = ollama.list()
+    except Exception:  # noqa: BLE001 - Ollama may be down; caller falls back to the default
+        return []
+    # ollama-python >= 0.4 returns an object with a ``.models`` list of items
+    # exposing ``.model``; older versions return a dict of {"name"/"model": ...}.
+    models = getattr(response, "models", None)
+    if models is None and isinstance(response, dict):
+        models = response.get("models", [])
+    names = []
+    for model in models or []:
+        name = getattr(model, "model", None)
+        if name is None and isinstance(model, dict):
+            name = model.get("model") or model.get("name")
+        if name:
+            names.append(name)
+    return names
+
+
+def choose_model(default_model_id):
+    """Let the user pick from the locally-installed Ollama models at startup.
+
+    Falls back to ``default_model_id`` when input is non-interactive (tests /
+    CI / piped stdin), when Ollama lists no models, or when the user just
+    presses Enter.
+    """
+    models = available_ollama_models()
+    if not models or not sys.stdin.isatty():
+        return default_model_id
+
+    default_installed = default_model_id in models
+    fallback = default_model_id if default_installed else models[0]
+    if not default_installed:
+        # Don't silently redirect: tell the user their configured default
+        # isn't pulled, so the "(default)" marker below (which only marks the
+        # real configured default) isn't misleading.
+        print(
+            f"Configured default {default_model_id!r} is not installed; "
+            f"falling back to {fallback!r}."
+        )
+    print("Available Ollama models:")
+    for index, name in enumerate(models, start=1):
+        marker = "  (default)" if name == default_model_id else ""
+        print(f"  {index}. {name}{marker}")
+
+    try:
+        choice = input(f"Pick a model by number [default: {fallback}]: ").strip()
+    except (KeyboardInterrupt, EOFError):
+        return fallback
+    if not choice:
+        return fallback
+    if choice.isdigit() and 1 <= int(choice) <= len(models):
+        return models[int(choice) - 1]
+    print(f"'{choice}' is not a valid choice; using {fallback}.")
+    return fallback
+
+
+# The model (the "brain"): a local Ollama model instead of a cloud provider.
+# Configure the default in your .env.local1 (copy .env.local1.example ->
+# .env.local1). You must have Ollama installed and the model pulled first:
+# `ollama pull <model_id>`. Running the module interactively lets you pick a
+# different installed model at startup (see choose_model / __main__).
+OLLAMA_MODEL_ID = os.getenv("OLLAMA_MODEL_ID", "qwen2.5:7b")
+
+# A ready-made agent on the configured default, so importing the module (and the
+# tests) get a working agent without any interactive prompt.
+weather_agent = build_agent(OLLAMA_MODEL_ID)
+
+
+# Interactive loop so we can test it from the terminal.
+if __name__ == "__main__":
+    selected_model_id = choose_model(OLLAMA_MODEL_ID)
+    # Rebuild only if the user picked something other than the default the
+    # module-level agent was already built with.
+    agent = weather_agent if selected_model_id == OLLAMA_MODEL_ID else build_agent(selected_model_id)
+
+    print(f"\nOllama Weather Agent (local {selected_model_id})\n")
+    print("Ask about the weather in a US location, e.g.:")
+    print("  What's the weather like in Seattle?")
+    print("Type 'exit' to quit.\n")
+
+    while True:
+        try:
+            user_input = input("> ").strip()
+            if not user_input:
+                continue
+            if user_input.lower() == "exit":
+                print("\nGoodbye!")
+                break
+            # The agent streams its answer to stdout itself, so we don't reprint it.
+            agent(user_input)
+            print()
+        except (KeyboardInterrupt, EOFError):
+            print("\nExiting...")
+            break
+        except Exception as error:  # noqa: BLE001 - surface any error to the user
+            print(f"\nError: {error}\nPlease try a different request.")

artificial_intelligence_local/tests/artificial_intelligence_local_test.py

@@ -0,0 +1,10 @@
+"""Placeholder test for the artificial-intelligence-local package.
+
+The template example tests were removed in the BU-3046 cleanup. Real tests
+(e.g. the weather agent and the contacts agent) are added in later PRs.
+This keeps the test suite green so the build/GHA has at least one test to collect.
+"""
+
+
+def test_placeholder():
+    assert True

artificial_intelligence_local/tests/contact_agent_test.py

@@ -0,0 +1 @@
+"""Tests for the contacts agent (stub). Filled in PR4."""

artificial_intelligence_local/tests/strands_wrapper_generator_test.py

@@ -0,0 +1,107 @@
+"""Tests for strands_wrapper_generator.
+
+These are pure AST/codegen tests -- no DB, no :3000 auth server -- driven by a
+small in-memory fixture class that exercises every selection rule.
+"""
+
+import ast
+import os
+import tempfile
+
+import strands_wrapper_generator as gen
+
+# A fixture *_local.py source covering every case the selection rule must handle.
+FIXTURE_SOURCE = '''
+from typing import Dict
+
+
+class WidgetsLocal(SomeBase):
+    def __init__(self, x=None):
+        ...
+
+    def get_widget_by_id(self, widget_id: int) -> Dict:
+        return {}
+
+    def get_widgets(self, name: str, limit: int = 10, *, active: bool = True) -> list:
+        return []
+
+    @staticmethod
+    def get_default_widget() -> dict:            # static -> skipped
+        return {}
+
+    def get_display_name(widget_dict: dict) -> str:   # no self -> skipped
+        return ""
+
+    def get_test_widget_id(self) -> int:         # test helper -> skipped
+        return 1
+
+    def _get_internal(self) -> None:             # private -> skipped
+        ...
+
+    def get_widget_by_id(self, widget_id: int) -> Dict:   # duplicate -> deduped
+        return {}
+
+    def insert_widget(self, widget_dict: dict) -> int:    # write -> skipped
+        return 0
+'''
+
+
+def _generate_from(source: str) -> str:
+    with tempfile.TemporaryDirectory() as d:
+        path = os.path.join(d, "widgets_local.py")
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(source)
+        return gen.generate(path)
+
+
+def test_output_is_valid_python():
+    ast.parse(_generate_from(FIXTURE_SOURCE))
+
+
+def test_wraps_only_read_only_instance_methods():
+    code = _generate_from(FIXTURE_SOURCE)
+    tree = ast.parse(code)
+    twins = {n.name for n in tree.body if isinstance(n, ast.FunctionDef) and n.name.endswith("_strand")}
+    assert twins == {"get_widget_by_id_strand", "get_widgets_strand"}
+
+
+def test_skips_static_noself_testhelper_private_and_writes():
+    code = _generate_from(FIXTURE_SOURCE)
+    for skipped in (
+        "get_default_widget_strand",   # static
+        "get_display_name_strand",     # no self
+        "get_test_widget_id_strand",   # test helper
+        "_get_internal_strand",        # private
+        "insert_widget_strand",        # write
+    ):
+        assert skipped not in code
+
+
+def test_deduplicates_repeated_method():
+    code = _generate_from(FIXTURE_SOURCE)
+    assert code.count("def get_widget_by_id_strand(") == 1
+
+
+def test_factory_and_class_import():
+    code = _generate_from(FIXTURE_SOURCE)
+    assert "from .widgets_local import WidgetsLocal" in code
+    assert "def _widgets() -> WidgetsLocal:" in code
+    assert "return WidgetsLocal()" in code
+
+
+def test_carries_over_annotation_imports():
+    # get_widget_by_id returns Dict, so the typing import must come along.
+    code = _generate_from(FIXTURE_SOURCE)
+    assert "from typing import Dict" in code
+
+
+def test_twin_body_calls_same_named_method_and_returns():
+    code = _generate_from(FIXTURE_SOURCE)
+    assert "get_widget_by_id_strand_result = _widgets().get_widget_by_id(widget_id)" in code
+    assert "return get_widget_by_id_strand_result" in code
+
+
+def test_keyword_only_and_default_args_preserved():
+    code = _generate_from(FIXTURE_SOURCE)
+    assert "def get_widgets_strand(name: str, limit: int = 10, active: bool = True) -> list:" in code
+    assert "_widgets().get_widgets(name, limit, active=active)" in code

artificial_intelligence_local/tests/weather_agent_test.py

@@ -0,0 +1,132 @@
+"""Tests for the Ollama weather agent.
+
+The NWS calls live in the `get_forecast` tool, so the important behavior can be
+tested fast and deterministically by mocking `requests` — no network or LLM
+needed. The live test at the bottom is skipped by default; it exercises the full
+Ollama -> tool -> answer path and needs Ollama running plus internet.
+"""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+import weather_agent
+
+
+def test_weather_agent_is_built():
+    """The module exposes a constructed agent, its tool, and a system prompt."""
+    assert weather_agent.weather_agent is not None
+    assert weather_agent.get_forecast is not None
+    assert isinstance(weather_agent.WEATHER_SYSTEM_PROMPT, str)
+    assert weather_agent.WEATHER_SYSTEM_PROMPT.strip() != ""
+
+
+def _mock_response(status_code, payload):
+    response = MagicMock(status_code=status_code)
+    response.json.return_value = payload
+    return response
+
+
+def test_get_forecast_formats_period():
+    """A valid location returns a one-line forecast with temperature + conditions."""
+    points = _mock_response(200, {
+        "properties": {"forecast": "https://api.weather.gov/gridpoints/SEW/124,67/forecast"},
+    })
+    forecast = _mock_response(200, {
+        "properties": {"periods": [{
+            "name": "Tonight",
+            "temperature": 53,
+            "temperatureUnit": "F",
+            "shortForecast": "Mostly Cloudy",
+            "windSpeed": "8 mph",
+            "windDirection": "SSW",
+        }]},
+    })
+
+    # get_forecast makes two GETs: points, then the forecast URL.
+    with patch("weather_agent.requests.get", side_effect=[points, forecast]):
+        answer = weather_agent.get_forecast(47.6062, -122.3321)
+
+    assert "53°F" in answer
+    assert "Mostly Cloudy" in answer
+
+
+def test_get_forecast_outside_us_is_refused():
+    """Negative case: a non-US / unknown location is refused, not invented.
+
+    The NWS only covers the US and returns a non-200 for anything else, so the
+    tool must say it has no data — and must NOT fabricate a temperature.
+    """
+    with patch("weather_agent.requests.get", return_value=_mock_response(404, {})):
+        answer = weather_agent.get_forecast(0, 0)
+
+    assert "United States" in answer
+    assert "°F" not in answer
+
+
+def test_available_ollama_models_parses_client_response():
+    """Model ids are extracted from the ollama client's `.models[].model`."""
+    item = MagicMock()
+    item.model = "qwen2.5:7b"
+    response = MagicMock(models=[item])
+
+    with patch("weather_agent.ollama.list", return_value=response):
+        assert weather_agent.available_ollama_models() == ["qwen2.5:7b"]
+
+
+def test_available_ollama_models_empty_when_ollama_down():
+    """If the ollama client raises (server down), we return [] to fall back."""
+    with patch("weather_agent.ollama.list", side_effect=ConnectionError):
+        assert weather_agent.available_ollama_models() == []
+
+
+def test_choose_model_non_interactive_uses_default_without_prompting():
+    """In tests / CI (stdin not a tty) the configured default is used, no input()."""
+    with patch("weather_agent.available_ollama_models", return_value=["a", "b"]), \
+            patch("weather_agent.sys.stdin.isatty", return_value=False), \
+            patch("weather_agent.input", side_effect=AssertionError("must not prompt")):
+        assert weather_agent.choose_model("b") == "b"
+
+
+def test_choose_model_picks_by_number():
+    """A valid number selects the matching model from the listed order."""
+    with patch("weather_agent.available_ollama_models", return_value=["a", "b", "c"]), \
+            patch("weather_agent.sys.stdin.isatty", return_value=True), \
+            patch("weather_agent.input", return_value="3"):
+        assert weather_agent.choose_model("a") == "c"
+
+
+def test_choose_model_invalid_choice_falls_back_to_default():
+    """Empty / out-of-range / garbage input falls back to the default model."""
+    with patch("weather_agent.available_ollama_models", return_value=["a", "b"]), \
+            patch("weather_agent.sys.stdin.isatty", return_value=True), \
+            patch("weather_agent.input", return_value="99"):
+        assert weather_agent.choose_model("a") == "a"
+
+
+def test_choose_model_default_not_installed_notes_and_uses_first(capsys):
+    """If the configured default isn't installed, note it and fall back to the
+    first listed model (pressing Enter selects that fallback)."""
+    with patch("weather_agent.available_ollama_models", return_value=["a", "b"]), \
+            patch("weather_agent.sys.stdin.isatty", return_value=True), \
+            patch("weather_agent.input", return_value=""):
+        assert weather_agent.choose_model("not-installed") == "a"
+
+    out = capsys.readouterr().out
+    assert "not-installed" in out and "not installed" in out
+
+
+@pytest.mark.skip(reason="live test: needs Ollama running + internet to api.weather.gov")
+def test_weather_agent_answers_live():
+    """End-to-end: ask for a US city and expect a weather-shaped answer.
+
+    The LLM is non-deterministic, so we assert the answer is non-empty AND
+    mentions a weather concept rather than checking exact wording.
+    """
+    weather_terms = ("°f", "temperature", "forecast", "cloudy", "rain", "sunny", "wind")
+    answer = str(weather_agent.weather_agent("What's the weather like in Seattle?")).strip().lower()
+
+    assert answer != ""
+    assert any(term in answer for term in weather_terms), (
+        f"answer did not look weather-related: {answer!r}"
+    )

artificial_intelligence_local-0.0.1b3046.dist-info/METADATA

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: artificial-intelligence-local
+Version: 0.0.1b3046
+Summary: PyPI artificial-intelligence-local Python Package owned by Circlez.ai
+Home-page: https://github.com/circles-zone/artificial-intelligence-local-python-package
+Author: Circles
+Author-email: info@circlez.ai
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+Requires-Dist: python-sdk-remote
+Requires-Dist: logger-local
+Requires-Dist: strands-agents
+Requires-Dist: ollama
+Requires-Dist: python-dotenv
+Requires-Dist: requests
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: summary
+
+PyPI artificial-intelligence-local Python Package owned by Circlez.ai
+JIRA Work Item: https://circles-zone.atlassian.net/browse/BU-3046
+GHA: https://github.com/circles-zone/artificial-intelligence-local-python-package/actions

artificial_intelligence_local-0.0.1b3046.dist-info/RECORD

@@ -0,0 +1,14 @@
+artificial_intelligence_local/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+artificial_intelligence_local/src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+artificial_intelligence_local/src/contact_agent.py,sha256=KJbGUz-BqWpOCK8aTMI_Gg1r-5OHeY03xJ7zXmxSkVc,216
+artificial_intelligence_local/src/strands_wrapper_generator.py,sha256=pTjZOMx7m3gNeMRqRZT-3hY2tmk5WipPTtx7rjGj1Oc,8901
+artificial_intelligence_local/src/weather_agent.py,sha256=19NwPhshXMPirCZcM76rJTwzW-w2HNGBhldJDPa-8aE,8553
+artificial_intelligence_local/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+artificial_intelligence_local/tests/artificial_intelligence_local_test.py,sha256=howtqD2rHlK9Zg08JnyPmZgXz-d4o83Aikti8kQIlL4,344
+artificial_intelligence_local/tests/contact_agent_test.py,sha256=erit-d8IS60Auj1S4zY1QPoOMj_nGspCT2eDloyomg4,58
+artificial_intelligence_local/tests/strands_wrapper_generator_test.py,sha256=nnGmzE2PrUYgv-I6TYhxwJz7qy2zQE9Jk9yR1VrxrWI,3390
+artificial_intelligence_local/tests/weather_agent_test.py,sha256=iWmUMUsBYtycuVqhxr13obRd2Kzkhs5OeBuv2cpFUnE,5492
+artificial_intelligence_local-0.0.1b3046.dist-info/METADATA,sha256=UxyPy7-E1IwQTtHzCzeEN_f-KjlfT_R7FOQRH_ck31E,991
+artificial_intelligence_local-0.0.1b3046.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+artificial_intelligence_local-0.0.1b3046.dist-info/top_level.txt,sha256=QAJP8cTE3SKcbE58zw4EH_qDgZqVNktdTyEemkzGXoI,30
+artificial_intelligence_local-0.0.1b3046.dist-info/RECORD,,

artificial_intelligence_local-0.0.1b3046.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

artificial_intelligence_local-0.0.1b3046.dist-info/top_level.txt

@@ -0,0 +1 @@
+artificial_intelligence_local