Compare commits

...

15 Commits

Author SHA1 Message Date
javis-bot
49050b18a9 chore(app): version 0.1.34
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 18:09:12 +09:00
javis-bot
9f62bfb059 fix(voice): raise the consonant band by 12 dB before transcription
A dark microphone or a speaker who swallows first consonants and
sentence ends loses the band above 1 kHz first: in the live
recordings "자비스" came out as "아비스"/"다비스" and "서울" as "어우".
loudness_equalise now raises it with a one-octave shelf at 1 kHz.

Measured with large-v3-turbo: 25 sure live utterances 5.0% -> 3.4% CER,
FLEURS Korean test split (382 clips, held out) 5.16% -> 4.98%. The real
noise check stays at 108 clips with no text.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 18:09:05 +09:00
javis-bot
e428aad58a chore(app): version 0.1.33
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 17:25:49 +09:00
javis-bot
a665dd8d21 revert(voice): back to upstream songbird 0.6.1, nothing was heard with the held-packet patch
With 0.1.32 (songbird vendored with packets of an unnamed SSRC held until
Discord's Speaking op names it) the bot heard nobody on the live server
from its 16:57 join on 2026-11-18, while 0.1.30 heard every request at
15:58 the same day, and the speaker's Discord was heard by everyone else.
The patch is the only receive change between the two, and the cause was
not found (it passed the two-bot test server runs), so it is removed and
the first ~100 ms of a speaker's first utterance after a join is lost
again, as in 0.1.30.

This reverts 81d1e26 and 9199ccb.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 17:24:58 +09:00
javis-bot
a5afdbb221 chore(app): version 0.1.32
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 16:22:30 +09:00
javis-bot
9199ccbd0e fix(voice): release held packets within 20 ms once the speaker is named
Held packets were only processed before the same SSRC's next packet, so
a short first utterance that ended before Discord's Speaking op came was
dropped after a second. The UDP task now also releases every newly named
SSRC's held packets on its 20 ms playout tick.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 16:22:30 +09:00
javis-bot
2a95f58a0e chore(app): version 0.1.31
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 16:15:23 +09:00
javis-bot
81d1e26f61 fix(voice): keep the first packets of a speaker until Discord names them
Discord names a speaker's SSRC in the Speaking op only the first time
they speak, and the op arrives after their first UDP packets. songbird
0.6.1 dropped the DAVE packets it could not decrypt yet, so the first
~100 ms of the first thing each person said after a join were lost
(live 2026-11-18: "자비스 서울 날씨 어때" arrived as "아비 서울날씨
어때", and the first call after the 01:20 start as "아비스").

songbird is vendored in app/vendor/songbird with one patch: packets of
an unnamed SSRC are held (1 s, 50 packets each, 32 SSRCs) and processed
in arrival order once it is named, and the Speaking event is sent before
the SSRC is named so handlers know the speaker first.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 16:15:07 +09:00
javis-bot
88ee5ec2cb feat(weather): the app's log names the service that gave the weather
The source line (KMA, open-meteo or met.no for now; KMA and open-meteo
day counts for a forecast) only went to debug_log, which is off by
default and muted while the worker's brain answers, so a live answer
such as "흐림" could not be traced to its service. It now goes to the
llm log tab without the place or the key.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 16:10:06 +09:00
javis-bot
2e90c47a95 chore(app): version 0.1.30
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 11:21:46 +09:00
javis-bot
c7655c58f4 feat(weather): detail on request, 소나기 in 단기예보, weekday counts in the schema
- detail (only when the user asks for more detail) adds the humidity, the
  wind in m/s and the rain amount: now the last hour's rain (KMA RN1,
  open-meteo precipitation), a 단기예보 day its mean humidity and strongest
  wind, an open-meteo day its strongest wind and rain total.
- 단기예보's PTY 4 (소나기) was missing, so a showery afternoon under a
  clear sky came out as 맑음.
- days_ahead's description lists each coming weekday's count from today:
  with the new argument qwen3:8b counted a Wednesday's weekend as 2.

Evals: evals/test_weather_detail.py, test_weather_forecast_days.py,
test_weather_district_place.py (qwen3:8b, 27/27 over three runs).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 11:21:46 +09:00
javis-bot
b4f8f71dd2 chore(app): version 0.1.29
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 11:08:15 +09:00
javis-bot
9ba26c5bac feat(weather): districts such as 부산 연제구 found on OpenStreetMap
open-meteo's geocoder knows cities only, in Latin spellings, and matches a
non-Latin name loosely: "부산" gave a village called Pusan 140 km from
Busan. A non-Latin name now goes to OpenStreetMap's Nominatim first (any
language, down to districts), and a Latin name open-meteo does not know
goes there before the LLM romanisation and the wider-area retries. The
answer names the place in the user's own words, and KMA gets that spot's
grid point. Eval: evals/test_weather_district_place.py.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 11:08:15 +09:00
javis-bot
1bef5db912 chore(app): version 0.1.28
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 10:57:23 +09:00
javis-bot
17927b6450 feat(weather): KMA forecasts for a later day (days_ahead, days)
getWeather takes days_ahead (days from today, up to 10) and days (a span,
2 for a weekend). Inside Korea with the app's KMA key: 단기예보 for today
to 3 days ahead (morning and afternoon weather, lowest and highest, highest
chance of rain), then 중기기온 and 중기육상 for the nearest of 32 KMA cities
and its region. Days KMA does not give, and every KMA failure, come from
open-meteo's daily forecast. days_ahead 0 with more days gives the weather
now, then each day. Eval: evals/test_weather_forecast_days.py.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 10:57:12 +09:00
16 changed files with 990 additions and 45 deletions

View File

@@ -36,7 +36,7 @@
- 원하면 게임 중에는 봇을 일시정지할 수 있습니다.
- **안티치트 보호**: 뱅가드 같은 안티치트가 걸린 게임이 실행 중이면 키보드·마우스 자동 조작을 막고 그 이유를 알려 줍니다.
- **기존 기능 유지**: 메모리, 날씨, 웹 검색, 식단 기록, MCP, 브라우저 제어를 그대로 가져갑니다.
- **기상청 날씨**: 관리 앱 "기능" 화면에 기상청 API허브 인증키를 넣으면 한국 안의 현재 날씨를 기상청에서 받습니다(초단기실황조회, 초단기예보조회 활용신청 필요). 키가 없거나 한국 밖이면 open-meteo, 그다음 met.no에서 받습니다.
- **기상청 날씨**: 관리 앱 "기능" 화면에 기상청 API허브 인증키를 넣으면 한국 안의 현재 날씨와 10일 뒤까지의 예보("내일 날씨", "주말 날씨")를 기상청에서 받습니다. "부산 연제구"처럼 구 단위로 물으면 그 구의 날씨를 답하고(장소는 OpenStreetMap에서 찾습니다), "자세히" 물으면 습도, 바람, 강수량까지 답합니다(초단기실황조회, 초단기예보조회, 단기예보조회, 중기기온조회, 중기육상예보조회 활용신청 필요). 키가 없거나 한국 밖이면 open-meteo에서 받고, 현재 날씨는 그다음 met.no에서 받습니다.
- **관리 앱**:
- 첫 실행 마법사, 대시보드, 모델 다운로드, 기능별 켜기/끄기를 제공합니다.
- 로그 화면에서 로그를 보고, 복사하고, 내려받을 수 있습니다. 비밀값은 자동으로 가립니다.

2
app/Cargo.lock generated
View File

@@ -1520,7 +1520,7 @@ checksum = "3bd1574e617a9a6c1f8f8181bd7e841e1f20e4277607ef28945765188d6284d4"
[[package]]
name = "jarvis-app"
version = "0.1.27"
version = "0.1.34"
dependencies = [
"async-trait",
"base64 0.22.1",

View File

@@ -1,6 +1,6 @@
[package]
name = "jarvis-app"
version = "0.1.27"
version = "0.1.34"
edition = "2021"
rust-version = "1.85"
description = "Jarvis v2 Windows app core: Discord voice, voice worker supervisor, chat channels"

4
app/shell/Cargo.lock generated
View File

@@ -2637,7 +2637,7 @@ checksum = "3bd1574e617a9a6c1f8f8181bd7e841e1f20e4277607ef28945765188d6284d4"
[[package]]
name = "jarvis-app"
version = "0.1.27"
version = "0.1.34"
dependencies = [
"async-trait",
"base64 0.22.1",
@@ -2666,7 +2666,7 @@ dependencies = [
[[package]]
name = "jarvis-shell"
version = "0.1.27"
version = "0.1.34"
dependencies = [
"jarvis-app",
"serde_json",

View File

@@ -1,6 +1,6 @@
[package]
name = "jarvis-shell"
version = "0.1.27"
version = "0.1.34"
edition = "2021"
rust-version = "1.85"
description = "Jarvis v2 management app window (Tauri 2 over the app core's AdminApi)"

View File

@@ -86,8 +86,8 @@ manages the MCP servers it connects.
`kmaApiKey`, never in the settings file or `config/brain.json`, and saving `mcpServers` keeps it.
On start the app passes it to the worker in `JARVIS_KMA_API_KEY`; the worker takes that variable
out of its environment before any child process starts, and only the weather tool uses it
(current weather inside Korea from KMA, else open-meteo, then met.no). Without a key nothing
changes.
(the weather now and the forecast up to 10 days ahead inside Korea from KMA, else open-meteo;
the weather now then met.no). Without a key nothing changes.
- Each server's outcome (its tool count, or why it failed) is a worker line in the LLM log tab,
also without debug logging. MCP servers are programs the PC runs; the screen says to add only
trusted ones.

View File

@@ -23,7 +23,7 @@
- **게임 중 LLM이 답하는 동안**: STT와 LLM은 같은 GPU를 씁니다. 10명이 쉬지 않고 말하며 부분 전사를 계속 돌리면 LLM 출력이 1/2.5~1/3로 줄었습니다(M0 `gamemode_stt`). 그래서 게임 중에 LLM이 답을 만드는 동안에는 부분 전사를 멈추고(그동안 실시간 자막이 바뀌지 않음), 말이 끝난 뒤의 최종 전사는 기다리지 않고 바로 처리합니다. 게임이 없을 때는 LLM이 답하는 동안에도 부분 전사를 그대로 합니다(사용자 결정, 2026-11-10). 최종 전사가 부분 전사보다 먼저입니다. 멈추기로 한 것은 M0 `gamemode_tune` 측정 결과입니다(2026-11-11): 2초 간격은 37.5 tok/s, 음성 첫 문장 0.89초에 최종 전사 대기가 최대 1.2초였고, 멈추면 64.9 tok/s, 0.55초였습니다. 부분 전사를 멈췄을 때 beam 2~3 최종 전사와 긴 말의 실제 지연은 아직 재지 않았습니다([pc-features.md](pc-features.md#자동-조절-측정-m0-gamemode_tune-2026-11-11)).
- **부분 전사는 2명씩만 묶음(M1 실측)**: Whisper 인코더는 말 길이와 상관없이 늘 30초 창을 계산해서, 묶어도 비용이 사람 수에 비례합니다(RTX 5050에서 1명 0.2초, 10명 2.1초). 10명분 부분 전사를 한 번에 돌리면 그동안 들어온 최종 전사가 2초 넘게 기다려서, 부분 전사는 한 번에 2명까지만 돌리고 그 사이에 최종 전사가 먼저 들어가게 했습니다. 여러 명이 함께 말하면 자막은 늦어지고 사람마다 가장 최근 소리만 전사합니다. 인코더 창을 줄이면 4~7배 빨라졌지만 같은 문장을 되풀이하는 오류가 생겨 쓰지 않습니다.
- **호출어 힌트**: 등록한 호출어를 STT에 힌트로 넘겨 잘못 알아듣는 일을 줄입니다. 힌트만 쓰면 웃음소리에서 "자비스"를 지어내거나 실제 문장 끝에 "자비스"를 붙여서(M1 측정, 2026-11-11), 힌트가 있으면 같은 소리를 힌트 없이도 한 번 더 해석해 그 결과로 판단합니다. 힌트 결과는 호출어 개수가 힌트 없는 결과와 정확히 같을 때만 쓰므로, 힌트가 호출어를 더하거나 빼거나 비슷한 말("서비스", "자비수")을 호출어로 바꾸지 못합니다. "자비수" 같은 비슷한 말을 호출어로 볼지는 호출 판정(M4)이 정합니다.
- **음량 맞추기**: 사람마다 목소리 크기가 달라도 같은 크기로 맞춰 STT에 넣습니다. 목소리가 있는 구간만 재서 -20dBFS로 맞추고(최대 +40dB, 낮은 웅웅거림 제거, 큰 소리는 찌그러지지 않게 부드럽게 눌러 줌), 클릭이나 노크 소리가 음량을 정하지 않게 합니다. 측정하면 -60dBFS 속삭임부터 찌그러질 만큼 큰 소리까지 똑같이 받아 적었습니다.
- **음량 맞추기**: 사람마다 목소리 크기가 달라도 같은 크기로 맞춰 STT에 넣습니다. 목소리가 있는 구간만 재서 -20dBFS로 맞추고(최대 +40dB, 낮은 웅웅거림 제거, 큰 소리는 찌그러지지 않게 부드럽게 눌러 줌), 클릭이나 노크 소리가 음량을 정하지 않게 합니다. 측정하면 -60dBFS 속삭임부터 찌그러질 만큼 큰 소리까지 똑같이 받아 적었습니다. 음량을 재기 전에 1kHz 위 자음 대역("ㅈ", "ㅅ")을 12dB 올립니다. 마이크가 어둡거나 첫 자음과 말끝을 흘리는 사람의 "자비스"가 "아비스"로 들리던 것을 줄입니다(실제 디스코드 음성 25개 5.0%→3.4%, FLEURS 한국어 382개 5.16%→4.98%).
- **잡음 거르기와 헛 전사 막기**: 목소리가 분명한 구간(음성 확률 0.5 이상)이 0.25초 넘게 있어야 STT를 돌립니다. 키보드, 마우스, 발소리, 청소기 같은 잡음은 여기서 걸러집니다. 기침, 웃음처럼 목소리 같은 소리는 STT까지 가지만 결과의 토큰당 평균 확신도(-0.7 이상)와 반복 여부로 거릅니다. 실제 잡음 54개(ESC-50)를 원래 크기와 -25dBFS로 넣은 108개를 호출어 힌트를 켠 워커에 넣으니 103개는 STT까지 가지 않았고, STT까지 간 5개(기침, 웃음, 울음)도 모두 빈 결과였습니다. 그 잡음 위에 말한 문장 89개는 문자 오류율 평균 4.8%였고, 남은 문제는 웃음 직후 "감사합니다." 한 번(확신도가 기준선에 걸침), 시끄러운 잡음 속 짧은 단어 2개 누락, 같은 단어 세 번 반복 한 번입니다. 이 모델(large-v3-turbo)의 "말 없음" 확률은 늘 0이라 쓰지 않습니다.
- **RealtimeSTT 사용 범위**: RealtimeSTT는 화자 하나에 인스턴스 하나 구조라 10명이면 모델을 10번 올립니다. 그래서 설계(부분/최종 전사, VAD 결합)만 참고하고, **모델 1개를 10명이 공유하는 배치 방식**으로 직접 구현합니다.
- **선택지**: 더 낮은 지연이 필요하면 sherpa-onnx 스트리밍 모델을 "초고속" 옵션으로 검토합니다(한국어 정확도 확인 후).

View File

@@ -0,0 +1,32 @@
"""
Eval: a request for the weather in detail reaches getWeather as detail=true, and a plain one does not.
With detail getWeather also gives the humidity, the wind and the rain amount (2026-11-18);
without it the answer stays one short sentence for the voice reply.
Run: EVAL_JUDGE_MODEL=qwen3:8b ./scripts/run_evals.sh weather_detail
"""
import pytest
from conftest import requires_judge_llm
from test_weather_forecast_days import _ask
def _detail(args):
return (args or {}).get("detail") in (True, "true", "True")
@pytest.mark.eval
@requires_judge_llm
class TestWeatherDetail:
@pytest.mark.parametrize("query", ["부산 연제구 날씨 자세히 알려 줘", "give me the detailed weather for Busan"])
def test_asked_in_detail_detail_is_set(self, mock_config, eval_db, eval_dialogue_memory, query):
args = _ask(mock_config, eval_db, eval_dialogue_memory, query)
assert args is not None, "getWeather was not called"
assert _detail(args), args
def test_a_plain_question_is_not_detailed(self, mock_config, eval_db, eval_dialogue_memory):
args = _ask(mock_config, eval_db, eval_dialogue_memory, "부산 연제구 날씨 어때?")
assert args is not None, "getWeather was not called"
assert not _detail(args), args

View File

@@ -0,0 +1,25 @@
"""
Eval: a district the user names reaches getWeather whole ("부산 연제구"), not only its city.
getWeather finds districts on OpenStreetMap (2026-11-18), so the place argument must keep
the district for the answer to be about that spot.
Run: EVAL_JUDGE_MODEL=qwen3:8b ./scripts/run_evals.sh weather_district_place
"""
import pytest
from conftest import requires_judge_llm
from test_weather_forecast_days import _ask
@pytest.mark.eval
@requires_judge_llm
@pytest.mark.parametrize("query,district", [
("부산 연제구 날씨 어때?", "연제"),
("서울 강남구 내일 날씨 알려 줘", "강남"),
])
def test_the_district_is_in_the_place(mock_config, eval_db, eval_dialogue_memory, query, district):
args = _ask(mock_config, eval_db, eval_dialogue_memory, query)
assert args is not None, "getWeather was not called"
assert district in (args.get("location") or ""), args

View File

@@ -0,0 +1,78 @@
"""
Eval: a question about a later day reaches getWeather as that day (days_ahead/days).
Before getWeather took days_ahead/days (2026-11-18), "내일 날씨 어때?" was answered
with the weather now. The model counts the days from today's date in the context:
tomorrow is 1, this weekend is the coming Saturday with 2 days, and a plain
question about the weather stays the weather now (no days_ahead or 0).
Runs like the v2 brain (compact prompt, intent judge, Korean replies).
Run: EVAL_JUDGE_MODEL=qwen3:8b ./scripts/run_evals.sh weather_forecast_days
"""
from datetime import date
from unittest.mock import patch
import pytest
from conftest import requires_judge_llm
from helpers import JUDGE_BASE_URL, ToolCallCapture, create_mock_tool_run
def _ask(mock_config, eval_db, eval_dialogue_memory, query):
from helpers import JUDGE_MODEL
from jarvis.memory.history import HistoryContext
from jarvis.reply import turn_state
from jarvis.reply.engine import run_reply_engine
mock_config.ollama_base_url = JUDGE_BASE_URL
mock_config.ollama_chat_model = JUDGE_MODEL
capture = ToolCallCapture()
turn_state.reset()
try:
with patch('jarvis.reply.engine.run_tool_with_retries', side_effect=create_mock_tool_run(capture, {
"getWeather": "서울 날씨는 맑음, 최저 -1도, 최고 4도, 강수확률 0%입니다.",
})), patch('jarvis.reply.engine.get_location_context_with_timezone',
return_value=("Location: Seoul, South Korea", None)):
reply = run_reply_engine(db=eval_db, cfg=mock_config, tts=None, text=query,
dialogue_memory=eval_dialogue_memory, history=HistoryContext(),
legacy_memory=False, default_language="Korean",
compact_prompt=True, intent_judge=True)
finally:
turn_state.reset()
args = capture.get_args("getWeather")
print(f"\n forecast days [{JUDGE_MODEL}] {query!r}: tools={capture.tool_names()} "
f"args={args} reply={(reply or '')[:160]!r}")
return args
def _num(args, name):
try:
return int(float((args or {}).get(name) or 0))
except (TypeError, ValueError):
return 0
@pytest.mark.eval
@requires_judge_llm
class TestWeatherForecastDays:
@pytest.mark.parametrize("query", ["내일 날씨 어때?", "what's the weather tomorrow?"])
def test_tomorrow_is_one_day_ahead(self, mock_config, eval_db, eval_dialogue_memory, query):
args = _ask(mock_config, eval_db, eval_dialogue_memory, query)
assert args is not None, "getWeather was not called"
assert _num(args, "days_ahead") == 1, args
def test_the_weekend_is_the_coming_saturday_and_sunday(self, mock_config, eval_db, eval_dialogue_memory):
today = date.today()
if today.weekday() >= 5:
pytest.skip("on a weekend day 'this weekend' has two readings")
args = _ask(mock_config, eval_db, eval_dialogue_memory, "이번 주말 날씨 어때?")
assert args is not None, "getWeather was not called"
assert _num(args, "days_ahead") == 5 - today.weekday(), args
assert _num(args, "days") >= 2, args
def test_the_weather_now_stays_now(self, mock_config, eval_db, eval_dialogue_memory):
args = _ask(mock_config, eval_db, eval_dialogue_memory, "지금 날씨 어때?")
assert args is not None, "getWeather was not called"
assert _num(args, "days_ahead") == 0 and _num(args, "days") <= 1, args

View File

@@ -35,3 +35,13 @@ def debug_log(message: str, category: str = "debug") -> None:
print(f"[{category:^10}] {message}", file=sys.stderr)
except Exception:
pass
def notice(message: str, category: str = "debug") -> None:
"""A line that is written also without debug logging, to the process's original stderr, so it
still reaches the app's log while the voice worker mutes the reply engine's output. It must carry
no question, answer, place or other text from the conversation."""
try:
print(f"[{category:^10}] {message}", file=sys.__stderr__, flush=True)
except Exception:
pass

View File

@@ -2,11 +2,12 @@
import math
import os
from collections import Counter
from datetime import datetime, timedelta, timezone
import requests
from typing import Dict, Any, Optional
from ...debug import debug_log
from ...debug import debug_log, notice
from ...utils.location import get_location_info
from ..base import Tool, ToolContext
from ..types import ToolExecutionResult
@@ -206,6 +207,28 @@ _MET_NO_URL = "https://api.met.no/weatherapi/locationforecast/2.0/compact"
_MET_NO_HEADERS = {"User-Agent": "jarvis-voice-assistant/2 github.com/isair/jarvis"}
# OpenStreetMap's place search: any language, down to districts (부산 연제구), which open-meteo's
# geocoder (cities, Latin spellings) does not know. Its policy asks for an identifying User-Agent.
_NOMINATIM_URL = "https://nominatim.openstreetmap.org/search"
def _osm_place(name: str) -> Optional[Dict[str, Any]]:
"""The place OpenStreetMap finds for a name: {'lat', 'lon', 'country_code'}; None if none or on failure."""
try:
resp = requests.get(_NOMINATIM_URL, headers=_MET_NO_HEADERS, timeout=_OPEN_METEO_TIMEOUT_SEC,
params={"q": name, "format": "jsonv2", "limit": 1, "addressdetails": 1})
resp.raise_for_status()
found = resp.json()
if not isinstance(found, list) or not found:
return None
place = found[0]
code = ((place.get("address") or {}).get("country_code") or "").upper() or None
return {"lat": float(place["lat"]), "lon": float(place["lon"]), "country_code": code}
except Exception as e:
debug_log(f" ⚠️ OpenStreetMap place search failed ({type(e).__name__})", "tools")
return None
def _met_no_wmo(symbol: str) -> Optional[int]:
"""The WMO code closest to a met.no symbol code ('lightrainshowers_night' -> 80)."""
s = (symbol or "").split("_")[0]
@@ -252,15 +275,44 @@ def _met_no_current(lat: float, lon: float) -> Dict[str, Any]:
# KMA (기상청 API허브): current weather inside Korea when the app gives a key (admin.spec.md).
KMA_KEY_ENV = "JARVIS_KMA_API_KEY"
_KMA_URL = "https://apihub.kma.go.kr/api/typ02/openApi/VilageFcstInfoService_2.0/"
_KMA_API = "https://apihub.kma.go.kr/api/typ02/openApi/"
_KMA_URL = _KMA_API + "VilageFcstInfoService_2.0/"
_KMA_MID_URL = _KMA_API + "MidFcstInfoService/"
_KMA_TIMEOUT_SEC = 5
_KST = timezone(timedelta(hours=9))
# KMA's own words: PTY (precipitation type, 0 = none) wins over SKY (sky state).
_KMA_PTY_KO = {1: "비", 2: "비나 눈", 3: "눈", 5: "빗방울", 6: "빗방울과 눈날림", 7: "눈날림"}
_KMA_PTY_WMO = {1: 63, 2: 69, 3: 73, 5: 51, 6: 68, 7: 71}
# 4 (소나기) is in 단기예보 only, 5 to 7 in 초단기실황/초단기예보 only.
_KMA_PTY_KO = {1: "비", 2: "비나 눈", 3: "눈", 4: "소나기", 5: "빗방울", 6: "빗방울과 눈날림", 7: "눈날림"}
_KMA_PTY_WMO = {1: 63, 2: 69, 3: 73, 4: 81, 5: 51, 6: 68, 7: 71}
_KMA_SKY_KO = {1: "맑음", 3: "구름 많음", 4: "흐림"}
_KMA_SKY_WMO = {1: 0, 3: 2, 4: 3}
_kma_key = ""
# 중기예보 places: (getMidTa city, lat, lon); getMidLandFcst's region comes from the city's code.
# Every code checked live against KMA on 2026-11-18.
_KMA_MID_CITIES = (
("11B10101", 37.5665, 126.9780), ("11B20201", 37.4563, 126.7052), ("11B20601", 37.2636, 127.0286),
("11B20305", 37.7599, 126.7800), ("11B20701", 37.2720, 127.4350), ("11B20606", 36.9921, 127.1129),
("11D10301", 37.8813, 127.7298), ("11D10401", 37.3422, 127.9202), ("11D20501", 37.7519, 128.8761),
("11D20401", 38.2070, 128.5918), ("11C20401", 36.3504, 127.3845), ("11C20404", 36.4800, 127.2890),
("11C20104", 36.6013, 126.6608), ("11C20101", 36.7845, 126.4503), ("11C20301", 36.8151, 127.1139),
("11C10301", 36.6424, 127.4890), ("11C10101", 36.9910, 127.9259), ("11F10201", 35.8242, 127.1480),
("21F10501", 35.9676, 126.7369), ("11F20501", 35.1595, 126.8526), ("21F20801", 34.8118, 126.3922),
("11F20401", 34.7604, 127.6622), ("11F20405", 34.9507, 127.4872), ("11H10701", 35.8714, 128.6014),
("11H10501", 36.5684, 128.7294), ("11H10201", 36.0190, 129.3435), ("11H20201", 35.1796, 129.0756),
("11H20101", 35.5384, 129.3114), ("11H20301", 35.2280, 128.6811), ("11H20701", 35.1800, 128.1076),
("11G00201", 33.4996, 126.5312), ("11G00401", 33.2541, 126.5600),
)
_KMA_MID_REGIONS = {"11B": "11B00000", "11D1": "11D10000", "11D2": "11D20000", "11C1": "11C10000",
"11C2": "11C20000", "11F1": "11F10000", "11F2": "11F20000", "11H1": "11H10000",
"11H2": "11H20000", "11G": "11G00000"}
# A forecast goes this many days ahead (KMA 중기예보's last day).
MAX_DAYS_AHEAD = 10
_WEEKDAYS_KO = "월화수목금토일"
_DAY_NAMES_KO = {0: "오늘", 1: "내일", 2: "모레"}
def _now() -> datetime:
return datetime.now(_KST)
def take_kma_key() -> None:
@@ -289,11 +341,10 @@ def _kma_grid(lat: float, lon: float) -> tuple:
return int(ra * math.sin(theta) + 43 + 0.5), int(ro - ra * math.cos(theta) + 136 + 0.5)
def _kma_items(service: str, key: str, base: datetime, nx: int, ny: int) -> list:
def _kma_get(url: str, key: str, params: Dict[str, Any]) -> list:
"""One KMA call's items; raises on any failure. The key is in the URL: never log the error text."""
resp = requests.get(_KMA_URL + service, timeout=_KMA_TIMEOUT_SEC, params={
"pageNo": 1, "numOfRows": 100, "dataType": "JSON", "base_date": base.strftime("%Y%m%d"),
"base_time": base.strftime("%H%M"), "nx": nx, "ny": ny, "authKey": key})
resp = requests.get(url, timeout=_KMA_TIMEOUT_SEC, params={
"pageNo": 1, "numOfRows": 100, "dataType": "JSON", **params, "authKey": key})
resp.raise_for_status()
body = (resp.json() or {}).get("response") or {}
code = (body.get("header") or {}).get("resultCode")
@@ -302,6 +353,182 @@ def _kma_items(service: str, key: str, base: datetime, nx: int, ny: int) -> list
return ((body.get("body") or {}).get("items") or {}).get("item") or []
def _kma_items(service: str, key: str, base: datetime, nx: int, ny: int, rows: int = 100) -> list:
return _kma_get(_KMA_URL + service, key, {"numOfRows": rows, "base_date": base.strftime("%Y%m%d"),
"base_time": base.strftime("%H%M"), "nx": nx, "ny": ny})
def _kma_failed(what: str, e: Exception) -> None:
why = str(e) if isinstance(e, (ValueError, KeyError)) else type(e).__name__
debug_log(f"KMA {what} failed ({why}); using open-meteo", "tools")
def _kma_half(cats: Dict[str, Dict[str, str]], pm: bool) -> Optional[str]:
"""Half a day's weather from 단기예보's hours: the commonest precipitation if any, else the commonest
(on a tie the cloudier) sky. None when the forecast has no hour of that half left."""
times = [t for t in cats.get("SKY", {}) if (t >= "1200") == pm]
if not times:
return None
wet = [p for p in (int(float(cats.get("PTY", {}).get(t, 0))) for t in times) if p in _KMA_PTY_KO]
if wet:
return _KMA_PTY_KO[Counter(wet).most_common(1)[0][0]]
skies = Counter(int(float(cats["SKY"][t])) for t in times)
return _KMA_SKY_KO.get(max(skies, key=lambda v: (skies[v], v)))
def _kma_short_days(lat: float, lon: float, key: str, now: datetime, offsets: list) -> Dict[int, Dict[str, Any]]:
"""단기예보 (out about 10 minutes after 02, 05, ..., 23 h) for the days it covers: today to 3 days ahead."""
t = now - timedelta(minutes=15)
hours = [h for h in (2, 5, 8, 11, 14, 17, 20, 23) if h <= t.hour]
base = (t.replace(hour=hours[-1]) if hours else (t - timedelta(days=1)).replace(hour=23)).replace(
minute=0, second=0, microsecond=0)
nx, ny = _kma_grid(lat, lon)
by_date: Dict[str, Dict[str, Dict[str, str]]] = {}
for i in _kma_items("getVilageFcst", key, base, nx, ny, rows=1500):
by_date.setdefault(i.get("fcstDate"), {}).setdefault(i.get("category"), {})[i.get("fcstTime")] = i.get("fcstValue")
out = {}
for off in offsets:
date = now.date() + timedelta(days=off)
cats = by_date.get(date.strftime("%Y%m%d")) or {}
if not (cats.get("TMN") or cats.get("TMX")): # a day the forecast does not (fully) cover
continue
temps = [float(v) for v in cats.get("TMP", {}).values()]
lo = float(next(iter(cats["TMN"].values()))) if cats.get("TMN") else min(temps, default=None)
hi = float(next(iter(cats["TMX"].values()))) if cats.get("TMX") else max(temps, default=None)
reh = [float(v) for v in cats.get("REH", {}).values()]
out[off] = {"date": date, "am": _kma_half(cats, False), "pm": _kma_half(cats, True), "min": lo,
"max": hi, "pop": max((int(float(v)) for v in cats.get("POP", {}).values()), default=None),
"humidity": sum(reh) / len(reh) if reh else None,
"wind_ms": max((float(v) for v in cats.get("WSD", {}).values()), default=None)}
return out
def _kma_mid_days(lat: float, lon: float, key: str, now: datetime, offsets: list) -> Dict[int, Dict[str, Any]]:
"""중기예보 (out about 30 minutes after 06 and 18 h) for the nearest KMA city and its region; its days
are counted from the day it came out, up to 10 days ahead."""
t = now - timedelta(minutes=30)
base = (t.replace(hour=18) if t.hour >= 18 else t.replace(hour=6) if t.hour >= 6
else (t - timedelta(days=1)).replace(hour=18)).replace(minute=0, second=0, microsecond=0)
city = min(_KMA_MID_CITIES, key=lambda c: (c[1] - lat) ** 2 + ((c[2] - lon) * math.cos(math.radians(lat))) ** 2)[0]
region = _KMA_MID_REGIONS.get(city[:3]) or _KMA_MID_REGIONS["11" + city[2:4]]
tm_fc = base.strftime("%Y%m%d%H%M")
ta = _kma_get(_KMA_MID_URL + "getMidTa", key, {"regId": city, "tmFc": tm_fc})[0]
land = _kma_get(_KMA_MID_URL + "getMidLandFcst", key, {"regId": region, "tmFc": tm_fc})[0]
out = {}
for off in offsets:
date = now.date() + timedelta(days=off)
n = (date - base.date()).days
am = land.get(f"wf{n}Am") or land.get(f"wf{n}")
pops = [p for p in (land.get(f"rnSt{n}Am"), land.get(f"rnSt{n}Pm"), land.get(f"rnSt{n}")) if p is not None]
if am is None and ta.get(f"taMax{n}") is None:
continue
out[off] = {"date": date, "am": am, "pm": land.get(f"wf{n}Pm") or am, "min": ta.get(f"taMin{n}"),
"max": ta.get(f"taMax{n}"), "pop": max(pops) if pops else None}
return out
def _kma_days(lat: float, lon: float, key: str, offsets: list) -> Dict[int, Dict[str, Any]]:
"""KMA's forecast for each day it has: 단기예보 first, 중기예보 for the rest; {} on failure."""
now = _now().astimezone(_KST)
out: Dict[int, Dict[str, Any]] = {}
if any(off <= 3 for off in offsets):
try:
out.update(_kma_short_days(lat, lon, key, now, offsets))
except Exception as e:
_kma_failed("short-term forecast", e)
rest = [off for off in offsets if off not in out]
if any(off >= 3 for off in rest):
try:
out.update(_kma_mid_days(lat, lon, key, now, rest))
except Exception as e:
_kma_failed("mid-term forecast", e)
return out
def _open_meteo_days(lat: float, lon: float, offsets: list) -> Dict[int, Dict[str, Any]]:
"""open-meteo's daily forecast (the place's own days) for the given days; {} on failure."""
try:
resp = requests.get("https://api.open-meteo.com/v1/forecast", timeout=_OPEN_METEO_TIMEOUT_SEC, params={
"latitude": lat, "longitude": lon, "timezone": "auto", "forecast_days": max(offsets) + 1,
"daily": "weather_code,temperature_2m_max,temperature_2m_min,precipitation_probability_max,"
"wind_speed_10m_max,precipitation_sum"})
resp.raise_for_status()
daily = (resp.json() or {}).get("daily") or {}
except Exception as e:
debug_log(f"open-meteo daily forecast failed ({type(e).__name__})", "tools")
return {}
def at(name: str, off: int):
values = daily.get(name) or []
return values[off] if off < len(values) else None
out = {}
for off in offsets:
code, date = at("weather_code", off), at("time", off)
if date is None or (code is None and at("temperature_2m_max", off) is None):
continue
ko = WMO_CODES_KO.get(code) if code is not None else None
out[off] = {"date": datetime.fromisoformat(date).date(), "am": ko, "pm": ko,
"min": at("temperature_2m_min", off), "max": at("temperature_2m_max", off),
"pop": at("precipitation_probability_max", off),
"wind_ms": _ms(at("wind_speed_10m_max", off)), "rain_mm": at("precipitation_sum", off)}
return out
def _ms(kmh: Optional[float]) -> Optional[float]:
return kmh / 3.6 if kmh is not None else None
def _detail_parts(humidity, wind_ms, rain_mm, wind_word: str, rain_word: str) -> list:
"""습도 / 바람 / 강수량 for an answer asked in detail; a dry spell's 0 mm is left out."""
parts = []
if humidity is not None:
parts.append(f"습도 {round(float(humidity))}%")
if wind_ms is not None:
parts.append(f"{wind_word} 초속 {round(float(wind_ms), 1):g}미터")
if rain_mm is not None and float(rain_mm) > 0:
parts.append(f"{rain_word} {round(float(rain_mm), 1):g}mm")
return parts
def _weekday_offsets() -> str:
"""The days_ahead of each coming weekday, so the model need not count them (a small model
counted 'this weekend' from a Wednesday as 2)."""
today = datetime.now()
days = ", ".join(f"{(today + timedelta(days=n)).strftime('%A')} {n}" for n in range(1, 8))
return f"From today, {today.strftime('%A')}: {days}."
def _day_span(args: Optional[Dict[str, Any]]) -> tuple:
"""(first, last) day asked for, counted from today: (0, 0) is the weather now."""
def num(name: str, default: int) -> int:
try:
return int(float((args or {}).get(name)))
except (TypeError, ValueError):
return default
first = min(max(num("days_ahead", 0), 0), MAX_DAYS_AHEAD)
return first, min(first + max(num("days", 1), 1) - 1, MAX_DAYS_AHEAD)
def _day_sentence(off: int, day: Dict[str, Any], place: str, detail: bool = False) -> str:
"""'내일(11월 19일 목요일) 서울 날씨는 오전 맑음, 오후 비, 최저 -1도, 최고 4도, 강수확률 60%입니다.'"""
d = day["date"]
when = f"{d.month}월 {d.day}일 {_WEEKDAYS_KO[d.weekday()]}요일"
if off in _DAY_NAMES_KO:
when = f"{_DAY_NAMES_KO[off]}({when})"
am, pm = day.get("am"), day.get("pm")
parts = [f"오전 {am}, 오후 {pm}" if am and pm and am != pm else am or pm]
if day.get("min") is not None:
parts.append(f"최저 {round(float(day['min']))}도")
if day.get("max") is not None:
parts.append(f"최고 {round(float(day['max']))}도")
if day.get("pop") is not None:
parts.append(f"강수확률 {round(float(day['pop']))}%")
if detail:
parts += _detail_parts(day.get("humidity"), day.get("wind_ms"), day.get("rain_mm"), "최대 바람", "강수량")
return f"{when} {place} 날씨는 " + ", ".join(p for p in parts if p) + "입니다."
def _kma_current(lat: float, lon: float, key: str, now: Optional[datetime] = None) -> Dict[str, Any]:
"""Current weather from KMA in open-meteo's 'current' keys plus 'condition_ko'; {} on failure.
@@ -331,6 +558,7 @@ def _kma_current(lat: float, lon: float, key: str, now: Optional[datetime] = Non
"weather_code": wmo,
"condition_ko": ko,
"wind_speed_10m": round(float(wind) * 3.6, 1) if wind is not None else None,
"precipitation": float(obs["RN1"]) if obs.get("RN1") is not None else None,
}
except Exception as e:
why = str(e) if isinstance(e, (ValueError, KeyError)) else type(e).__name__
@@ -351,6 +579,10 @@ class WeatherTool(Tool):
"Weather only (current + forecast). NOT for time-of-day, date, or "
"location questions — those are already in the assistant's context. "
"Use for ANY weather question: now, later today, tomorrow, this week. "
"For another day set days_ahead, the days from today's date in the "
"context to that day (tomorrow 1, up to 10), and days for more than one "
"day: a weekend is days_ahead to the coming Saturday with days 2, a week "
"is days 7. "
"Set location to the place the user asked about. If they named none, "
"set it to where the user has said they are, from the conversation or "
"what you remember about them. Otherwise leave it empty: the tool "
@@ -366,6 +598,18 @@ class WeatherTool(Tool):
"location": {
"type": "string",
"description": "City name or location (e.g., 'London', 'New York', 'Tokyo'): the place the user asked about, or else where the user has said they are (the conversation or your memory of them). Omit otherwise; the tool then auto-detects the user's location. Never ask the user for this argument."
},
"days_ahead": {
"type": "integer",
"description": "Days from today to the day asked about: omit or 0 for now, 1 for tomorrow, 2 for the day after, up to 10. " + _weekday_offsets()
},
"days": {
"type": "integer",
"description": "How many days from days_ahead on (default 1): 2 for a weekend (Saturday and Sunday), 7 for a week."
},
"detail": {
"type": "boolean",
"description": "true only when the user asks for more detail: the answer then also has the humidity, the wind and the rain amount."
}
},
"required": []
@@ -416,8 +660,27 @@ class WeatherTool(Tool):
debug_log(f" ⚠️ location detection error: {e}", "tools")
return None
@staticmethod
def _forecast_lines(lat: float, lon: float, country_code: Optional[str], first: int, last: int,
location_display: str, detail: bool = False) -> list:
"""A sentence for each day from first to last that a forecast has: KMA inside Korea with the
app's key, open-meteo for the days KMA does not give."""
offsets = list(range(first, last + 1))
days: Dict[int, Dict[str, Any]] = {}
kma_key = _kma_key_now()
if kma_key and country_code == "KR":
days = _kma_days(lat, lon, kma_key, offsets)
from_kma = len(days)
rest = [off for off in offsets if off not in days]
if rest:
days.update(_open_meteo_days(lat, lon, rest))
# Which service gave the answer, in the app's log (no place: it comes from the question).
notice(f"weather days {first}-{last}: {from_kma} from KMA, {len(days) - from_kma} from open-meteo", "llm")
place = location_display.split(",")[0].strip() or location_display
return [_day_sentence(off, days[off], place, detail) for off in offsets if off in days]
def run(self, args: Optional[Dict[str, Any]], context: ToolContext) -> ToolExecutionResult:
"""Get current weather for a location."""
"""Get the weather now, or the forecast for the days asked about, for a location."""
context.user_print("🌤️ Checking weather...")
try:
@@ -504,13 +767,24 @@ class WeatherTool(Tool):
"format": "json"
}
geo_response = requests.get(geocode_url, params=geocode_params, timeout=10)
geo_response.raise_for_status()
geo_data = geo_response.json()
# Open-Meteo knows cities only, in Latin spellings, and matches a
# non-Latin name loosely (live 2026-11-18: "부산" gave a village
# called Pusan 140 km away). A non-Latin name, and a Latin one
# open-meteo does not know (a district), is looked up on
# OpenStreetMap in the words the user used.
geo_data: Dict[str, Any] = {}
if location_str.isascii():
geo_response = requests.get(geocode_url, params=geocode_params, timeout=10)
geo_response.raise_for_status()
geo_data = geo_response.json()
osm = None if geo_data.get("results") else _osm_place(location_str)
if osm:
debug_log(" 📍 found on OpenStreetMap", "tools")
geo_data = {"results": [{"latitude": osm["lat"], "longitude": osm["lon"],
"name": location_str, "country_code": osm["country_code"]}]}
# Open-Meteo only matches Latin spellings, so a non-Latin name
# (e.g. Korean "서울") returns nothing. Retry once with an
# LLM-romanised name before giving up.
# Not on OpenStreetMap either (or it failed): retry open-meteo
# once with an LLM-romanised name before giving up.
if not geo_data.get("results"):
romanised = _romanise_place(location_str, getattr(context, "cfg", None))
if romanised:
@@ -562,12 +836,24 @@ class WeatherTool(Tool):
debug_log(f" 📍 resolved to {location_display} ({lat}, {lon})", "tools")
first, last = _day_span(args)
detail = (args or {}).get("detail") is True or str((args or {}).get("detail")).lower() == "true"
if first > 0:
lines = self._forecast_lines(lat, lon, country_code, first, last, location_display, detail)
if not lines:
return ToolExecutionResult(
success=False,
reply_text=f"Weather forecast temporarily unavailable for {location_display}."
)
context.user_print(f"✅ Forecast for {location_display.split(',')[0].strip()}")
return ToolExecutionResult(success=True, reply_text="\n".join(lines))
# Step 2: Get current weather + forecast
weather_url = "https://api.open-meteo.com/v1/forecast"
weather_params = {
"latitude": lat,
"longitude": lon,
"current": "temperature_2m,relative_humidity_2m,apparent_temperature,weather_code,wind_speed_10m,wind_gusts_10m",
"current": "temperature_2m,relative_humidity_2m,apparent_temperature,weather_code,wind_speed_10m,wind_gusts_10m,precipitation",
"hourly": "temperature_2m,weather_code",
"daily": "weather_code,temperature_2m_max,temperature_2m_min",
"forecast_days": 7,
@@ -577,12 +863,12 @@ class WeatherTool(Tool):
}
current: Dict[str, Any] = {}
source = "KMA"
kma_key = _kma_key_now()
if kma_key and country_code == "KR":
current = _kma_current(lat, lon, kma_key)
if current:
debug_log(" 🌤️ current weather from KMA", "tools")
if not current:
source = "open-meteo"
try:
weather_response = requests.get(weather_url, params=weather_params,
timeout=_OPEN_METEO_TIMEOUT_SEC)
@@ -591,12 +877,14 @@ class WeatherTool(Tool):
except Exception as e:
# Live 2026-11-18: the forecast server stopped answering while geocoding worked.
debug_log(f"open-meteo forecast failed ({type(e).__name__}); trying met.no", "tools")
source = "met.no"
current = _met_no_current(lat, lon)
if not current:
return ToolExecutionResult(
success=False,
reply_text=f"Weather data temporarily unavailable for {location_display}."
)
notice(f"weather now: {source}", "llm")
# Extract current weather values
temp_c = current.get("temperature_2m")
@@ -625,12 +913,17 @@ class WeatherTool(Tool):
if feels_like_c is not None and round(feels_like_c) != round(temp_c):
_t += f"(체감 {round(feels_like_c)}도)"
_ko_parts.append(_t)
if detail:
_ko_parts += _detail_parts(humidity, _ms(wind_speed), current.get("precipitation"),
"바람", "지난 1시간 강수량")
ko_sentence = ", ".join(_ko_parts) + "입니다."
# The reply is the clean Korean sentence ONLY — no English/°C source
# for the model to echo ("25도 Celsius"), no forecast firehose to
# ramble over. The model just echoes this one sentence.
lines = [ko_sentence]
if last > 0: # "this week": now, then each day
lines += self._forecast_lines(lat, lon, country_code, 0, last, location_display, detail)
reply_text = "\n".join(lines)

View File

@@ -54,6 +54,12 @@ TARGET_DB = -20.0 # loudness every speaker is brought to, dBFS RMS over the
MAX_GAIN_DB = 40.0 # a whisper at -60 dBFS still reaches the target; pure hiss is not blown up
MIN_GAIN_DB = -20.0
HIGHPASS_HZ = 60.0 # mains hum and desk rumble carry no speech
# Consonants ("ㅈ", "ㅅ") live above 1 kHz and are what a dark microphone or a swallowed syllable loses.
# Raised by a shelf that rises over one octave around HIGH_SHELF_HZ. Measured with large-v3-turbo:
# FLEURS Korean (held-out test split, 382 clips) 5.16% -> 4.98% CER, a dark real speaker 5.0% -> 3.4%;
# 6 dB did little, 18-24 dB no better on FLEURS and worse on the real speaker.
HIGH_SHELF_HZ = 1000.0
HIGH_SHELF_DB = 12.0
_KNEE = 0.8 # soft limiter: peaks above this bend smoothly towards the ceiling instead of clipping
_CEILING = 0.98
_WINDOW = 512
@@ -70,7 +76,10 @@ def loudness_equalise(x: np.ndarray, voiced: np.ndarray | None = None) -> np.nda
if len(x) == 0:
return x
spec = np.fft.rfft(x.astype(np.float64))
spec[np.fft.rfftfreq(len(x), 1 / TARGET_RATE) < HIGHPASS_HZ] = 0
freqs = np.fft.rfftfreq(len(x), 1 / TARGET_RATE)
spec[freqs < HIGHPASS_HZ] = 0
rise = np.clip(np.log2(np.maximum(freqs, 1.0) / HIGH_SHELF_HZ) + 0.5, 0.0, 1.0)
spec *= 10 ** (HIGH_SHELF_DB * rise / 20)
y = np.fft.irfft(spec, len(x))
n_win = -(-len(y) // _WINDOW)
frames = np.pad(y, (0, n_win * _WINDOW - len(y))).reshape(n_win, _WINDOW)

View File

@@ -108,6 +108,15 @@ its own streaming Silero VAD (512-sample windows, state kept between frames).
the gain kept between -20 and +40 dB, and peaks above 0.8 are soft-limited below 0.98 instead of
clipping. Measured: speech from -60 dBFS to clipped shouting was transcribed equally well, and quiet
speech under loud clicks or knocks better than with peak normalisation.
Before the level is measured, the band where consonants such as "ㅈ" and "ㅅ" live is raised by
12 dB: a shelf that rises over one octave from 707 Hz to 1.41 kHz (centred on 1 kHz) and stays
flat above. A dark microphone, or a speaker who swallows first consonants and sentence ends, loses
that band first ("자비스" heard as "아비스", "서울" as "어우"). Measured with large-v3-turbo on 32
real Discord utterances of such a speaker: 5.0% character errors on the 25 whose words are sure, down to 3.4%,
with sentence ends ("어때", "틀어줘") and wake words kept that were lost before; on FLEURS
Korean, tuned on the dev split (224 clips, 4.66% to 4.32%) and checked on the held-out test split
(382 clips, 5.16% to 4.98%). 6 dB changed little; 18 and 24 dB were no better on FLEURS and worse on
the real speaker. The noise check below is unchanged with it (108 clips, none with text).
### Scheduling
@@ -289,10 +298,25 @@ which carry Discord's own time.
brain adds each server's values to that server's environment only. Each server's outcome is printed without debug logging (category `llm`):
`MCP server <name>: <n> tool(s)`, or `Warning: MCP server <name> failed: <reason>`.
The KMA key (`JARVIS_KMA_API_KEY`, `app/src/admin.spec.md`) leaves the environment at the same
point; the weather tool keeps it and uses it only for the current weather inside Korea
(geocoded or detected country `KR`): KMA's 초단기실황 (temperature, humidity, wind,
precipitation) and 초단기예보 (the coming hour's sky). Any KMA failure falls back to open-meteo,
then met.no; the key is in KMA's URLs, so a failure is logged by its kind only.
point; the weather tool keeps it and uses it only for the weather inside Korea (geocoded or
detected country `KR`). Now: KMA's 초단기실황 (temperature, humidity, wind, precipitation) and
초단기예보 (the coming hour's sky). A later day (`getWeather` `days_ahead`, 1 to 10, and `days`
for a span such as a weekend; the schema lists each coming weekday's `days_ahead` from today
so the model need not count): 단기예보 for today to 3 days ahead (the morning's and the
afternoon's commonest precipitation, 소나기 included, or sky, the day's lowest and highest, the
highest chance of rain), then 중기예보 for the nearest of the KMA cities in `weather.py` and its region (중기기온,
중기육상). Days KMA does not give, and every KMA failure, come from open-meteo (now: then
met.no; later days: open-meteo's daily forecast only). The key is in KMA's URLs, so a failure is
logged by its kind only. Which service answered is printed without debug logging (category
`llm`, no place and no key): `weather now: KMA` (or `open-meteo`, `met.no`) and
`weather days <first>-<last>: <n> from KMA, <m> from open-meteo`. `detail` (only when the user asks for more detail) adds the
humidity, the wind in m/s and the rain amount: now the last hour's rain (KMA 초단기실황 RN1,
open-meteo `precipitation`; none from met.no), a 단기예보 day its mean humidity and strongest
wind, an open-meteo day its strongest wind and rain total; 중기예보 has none of these. A dry
0 mm is not said. The place is found by open-meteo's geocoder (cities, Latin spellings)
or OpenStreetMap's Nominatim (any language, down to districts such as 부산 연제구; a non-Latin
name goes there first, since open-meteo matches it loosely); only the place name is sent, with
the app's User-Agent, and the answer names the place in the user's own words.
- `prepare` tells the brain that `user` is saying a call whose partial transcript is `text` (the app
sends it while the speaker is still talking, `app/src/conversation.spec.md`). The brain runs the
intent judge's tool pick for it on its own thread, with the asker's dialogue memory and the tool

View File

@@ -5,7 +5,7 @@ from __future__ import annotations
import numpy as np
import pytest
from voice_worker.audio import InputConverter, loudness_equalise
from voice_worker.audio import HIGH_SHELF_DB, HIGH_SHELF_HZ, InputConverter, loudness_equalise
from voice_worker.protocol import (KIND_AUDIO, KIND_TTS, ProtocolError, decode_audio_frame, encode_audio_frame,
encode_tts_frame, decode_tts_frame)
@@ -171,3 +171,16 @@ def test_low_rumble_is_removed_before_levelling():
spec = np.abs(np.fft.rfft(y))
freqs = np.fft.rfftfreq(len(y), 1 / 16000)
assert spec[np.argmin(np.abs(freqs - 30))] < 0.01 * spec[np.argmin(np.abs(freqs - 220))]
@pytest.mark.unit
def test_consonant_band_is_raised_against_the_vowel_band():
"""A dark microphone (or a speaker who swallows consonants) loses the band above 1 kHz where
"ㅈ" and "ㅅ" live; it is raised by the shelf, the band below it is left as it was."""
t = np.arange(32000) / 16000
low, high = HIGH_SHELF_HZ / 4, HIGH_SHELF_HZ * 4
x = (0.05 * np.sin(2 * np.pi * low * t) + 0.05 * np.sin(2 * np.pi * high * t)).astype(np.float32)
spec = np.abs(np.fft.rfft(loudness_equalise(x)))
freqs = np.fft.rfftfreq(len(x), 1 / 16000)
ratio_db = 20 * np.log10(spec[np.argmin(np.abs(freqs - high))] / spec[np.argmin(np.abs(freqs - low))])
assert abs(ratio_db - HIGH_SHELF_DB) < 0.5

View File

@@ -3,6 +3,7 @@
import pytest
from unittest.mock import Mock, patch
import requests
from datetime import datetime, timedelta, timezone
from src.jarvis.tools.builtin.weather import (
WeatherTool,
@@ -106,16 +107,13 @@ class TestWeatherTool:
def test_run_non_latin_location_romanises_and_retries(self, mock_get, mock_romanise):
"""A Korean city name Open-Meteo can't geocode is romanised and retried.
Open-Meteo's geocoder only matches Latin spellings, so ``서울`` returns
no results. The tool must romanise to ``Seoul`` and retry rather than
Open-Meteo's geocoder only matches Latin spellings, so ``서울`` is first
looked up on OpenStreetMap (any language). When that finds nothing,
the tool must romanise to ``Seoul`` and retry rather than
dead-ending with "could not find location" (the failure the Korean-
locked deployment hit on every weather request)."""
mock_romanise.return_value = "Seoul"
geo_empty = Mock()
geo_empty.raise_for_status = Mock()
geo_empty.json.return_value = {} # no "results"
geo_seoul = Mock()
geo_seoul.raise_for_status = Mock()
geo_seoul.json.return_value = {
@@ -153,14 +151,16 @@ class TestWeatherTool:
},
}
mock_get.side_effect = [geo_empty, geo_seoul, weather_response]
osm_empty = Mock(raise_for_status=Mock())
osm_empty.json.return_value = []
mock_get.side_effect = [osm_empty, geo_seoul, weather_response]
result = self.tool.run({"location": "서울"}, self.context)
assert result.success is True
assert "Seoul" in result.reply_text
mock_romanise.assert_called_once()
# The romanised name must be what the second geocode actually queried.
# The romanised name must be what the geocode actually queried.
assert mock_get.call_args_list[1].kwargs["params"]["name"] == "Seoul"
@patch('requests.get')
@@ -426,13 +426,36 @@ class TestWeatherTool:
return met
mock_get.side_effect = get
result = self.tool.run({"location": "서울"}, self.context)
result = self.tool.run({"location": "Seoul"}, self.context)
assert result.success is True
assert "서울" in result.reply_text
assert WMO_CODES_KO[80] in result.reply_text
assert str(round(8.6)) in result.reply_text
@patch('requests.get')
def test_the_log_names_met_no_when_it_gave_the_weather_now(self, mock_get, capfd):
geo = Mock(status_code=200, raise_for_status=Mock())
geo.json.return_value = {"results": [{"latitude": 37.57, "longitude": 126.98,
"name": "서울", "country": "대한민국"}]}
met = Mock(status_code=200, raise_for_status=Mock())
met.json.return_value = {"properties": {"timeseries": [{"data": {
"instant": {"details": {"air_temperature": 8.6}},
"next_1_hours": {"summary": {"symbol_code": "cloudy"}}}}]}}
def get(url, *a, **k):
if "geocoding" in url:
return geo
if "open-meteo" in url:
raise requests.exceptions.Timeout("timed out")
return met
mock_get.side_effect = get
self.tool.run({"location": "Seoul"}, self.context)
err = capfd.readouterr().err
assert "weather now: met.no" in err and "서울" not in err
@pytest.mark.parametrize("symbol", ["lightsleet", "sleet_day", "heavysleetshowers_night"])
def test_met_no_sleet_stays_sleet_not_freezing_rain(self, symbol):
from src.jarvis.tools.builtin.weather import _met_no_wmo
@@ -453,7 +476,7 @@ class TestWeatherTool:
raise requests.exceptions.Timeout("timed out")
mock_get.side_effect = get
result = self.tool.run({"location": "서울"}, self.context)
result = self.tool.run({"location": "Seoul"}, self.context)
assert result.success is False
assert "unavailable" in result.reply_text.lower()
@@ -678,9 +701,9 @@ class TestKmaWeather:
"body": {"items": {"item": items}}}}
return r
def _obs(self, pty="0", t1h="4.9"):
def _obs(self, pty="0", t1h="4.9", rn1="0"):
return self._kma([{"category": c, "obsrValue": v} for c, v in
[("PTY", pty), ("REH", "72"), ("RN1", "0"), ("T1H", t1h), ("WSD", "2.5")]])
[("PTY", pty), ("REH", "72"), ("RN1", rn1), ("T1H", t1h), ("WSD", "2.5")]])
def _sky(self, first="3"):
# The coming hours, out of order: the earliest one is the sky now.
@@ -722,6 +745,23 @@ class TestKmaWeather:
assert len(kma) == 2 and all(p["authKey"] == self.KEY for p in kma)
assert all((p["nx"], p["ny"]) == (60, 127) for p in kma)
@pytest.mark.parametrize("key, source", [(True, "KMA"), (False, "open-meteo")])
@patch('requests.get')
def test_the_log_names_the_service_that_gave_the_weather_now_and_not_the_place(
self, mock_get, key, source, monkeypatch, capfd):
"""Live 2026-11-18: "흐림" could have come from either service, and nothing said which."""
if key:
monkeypatch.setenv("JARVIS_KMA_API_KEY", self.KEY)
else:
monkeypatch.delenv("JARVIS_KMA_API_KEY", raising=False)
mock_get.side_effect = self._routes()
self.tool.run({"location": "Seoul"}, self.context)
err = capfd.readouterr().err
assert f"weather now: {source}" in err
assert "Seoul" not in err and self.KEY not in err
@patch('requests.get')
def test_precipitation_wins_over_the_sky(self, mock_get, monkeypatch):
monkeypatch.setenv("JARVIS_KMA_API_KEY", self.KEY)
@@ -778,6 +818,48 @@ class TestKmaWeather:
assert result.success is True and "기온 11도" in result.reply_text
assert not any(self.KEY in str(c) for c in log.call_args_list)
@patch('requests.get')
def test_asked_in_detail_kma_gives_humidity_wind_and_the_last_hours_rain(self, mock_get, monkeypatch):
monkeypatch.setenv("JARVIS_KMA_API_KEY", self.KEY)
mock_get.side_effect = self._routes(obs=self._obs(pty="1", rn1="1.5"))
result = self.tool.run({"location": "Seoul", "detail": True}, self.context)
text = result.reply_text
assert "습도 72%" in text and "바람 초속 2.5미터" in text and "지난 1시간 강수량 1.5mm" in text
@patch('requests.get')
def test_not_asked_in_detail_the_answer_stays_short(self, mock_get, monkeypatch):
monkeypatch.setenv("JARVIS_KMA_API_KEY", self.KEY)
mock_get.side_effect = self._routes(obs=self._obs(pty="1", rn1="1.5"))
result = self.tool.run({"location": "Seoul"}, self.context)
assert "습도" not in result.reply_text and "바람" not in result.reply_text
@patch('requests.get')
def test_asked_in_detail_open_meteo_gives_humidity_and_wind_without_a_dry_hours_rain(
self, mock_get, monkeypatch):
monkeypatch.delenv("JARVIS_KMA_API_KEY", raising=False)
calls = []
base = self._routes(calls=calls)
weather = Mock(status_code=200, raise_for_status=Mock())
weather.json.return_value = {"current": {"temperature_2m": 11.0, "weather_code": 0,
"relative_humidity_2m": 55, "wind_speed_10m": 10.8,
"precipitation": 0.0}}
def get(url, *a, **k):
r = base(url, *a, **k)
return weather if "api.open-meteo.com/v1/forecast" in url else r
mock_get.side_effect = get
result = self.tool.run({"location": "Seoul", "detail": True}, self.context)
assert "습도 55%" in result.reply_text and "바람 초속 3미터" in result.reply_text
assert "강수량" not in result.reply_text
(p,) = [p for u, p in calls if "api.open-meteo.com/v1/forecast" in u]
assert "precipitation" in p["current"].split(",")
@pytest.mark.parametrize("place,lat,lon,grid", [
("서울", 37.5665, 126.9780, (60, 127)),
("부산", 35.1796, 129.0756, (98, 76)),
@@ -824,3 +906,382 @@ class TestKmaWeather:
assert "흐림" in result.reply_text or "구름 많음" in result.reply_text
assert any(p.get("authKey") == self.KEY for u, p in calls if "apihub.kma.go.kr" in u)
class TestForecast:
"""A later day (days_ahead/days): KMA 단기예보 and 중기예보 inside Korea, else open-meteo's daily forecast."""
KEY = "kma-test-key-123"
# Wednesday 18 November 2026, 10:20 KST.
NOW = datetime(2026, 11, 18, 10, 20, tzinfo=timezone(timedelta(hours=9)))
def setup_method(self):
self.tool = WeatherTool()
self.context = Mock(spec=ToolContext)
self.context.user_print = Mock()
self.context.cfg = Mock()
self.context.cfg.location_name = None
self.context.redacted_text = ""
@staticmethod
def _ok(payload):
r = Mock(status_code=200, raise_for_status=Mock())
r.json.return_value = payload
return r
def _kma(self, items):
return self._ok({"response": {"header": {"resultCode": "00"}, "body": {"items": {"item": items}}}})
@staticmethod
def _vilage_items():
"""단기예보: tomorrow (19th) clear in the morning, rain in the afternoon; Saturday (21st) cloudy."""
items = []
for date, sky_am, sky_pm, pty_pm, pops in [
("20261119", "1", "4", "1", ("10", "60")),
("20261120", "3", "3", "0", ("20", "20")),
("20261121", "4", "4", "0", ("30", "30")),
]:
for hour in range(0, 24):
t = f"{hour:02d}00"
am = hour < 12
items += [
{"category": "SKY", "fcstDate": date, "fcstTime": t, "fcstValue": sky_am if am else sky_pm},
{"category": "PTY", "fcstDate": date, "fcstTime": t, "fcstValue": "0" if am else pty_pm},
{"category": "POP", "fcstDate": date, "fcstTime": t, "fcstValue": pops[0] if am else pops[1]},
{"category": "TMP", "fcstDate": date, "fcstTime": t, "fcstValue": str(hour % 7)},
{"category": "REH", "fcstDate": date, "fcstTime": t, "fcstValue": "60" if am else "80"},
{"category": "WSD", "fcstDate": date, "fcstTime": t, "fcstValue": str(1 + hour % 4)},
]
items += [{"category": "TMN", "fcstDate": date, "fcstTime": "0600", "fcstValue": "-1.0"},
{"category": "TMX", "fcstDate": date, "fcstTime": "1500", "fcstValue": "4.0"}]
return items
def _routes(self, country_code="KR", lat=37.566, lon=126.9784, calls=None, fail_kma=False):
def get(url, *a, **k):
params = k.get("params") or {}
if calls is not None:
calls.append((url, params))
if "geocoding" in url:
return self._ok({"results": [{"latitude": lat, "longitude": lon, "name": "Seoul",
"country_code": country_code}]})
if "apihub.kma.go.kr" in url:
if fail_kma:
raise requests.exceptions.Timeout(f"timed out: {url}?authKey={self.KEY}")
if "getVilageFcst" in url:
return self._kma(self._vilage_items())
if "getMidTa" in url:
return self._kma([{"regId": params["regId"], "taMin4": -4, "taMax4": 5,
"taMin5": -2, "taMax5": 7, "taMin10": 2, "taMax10": 10}])
if "getMidLandFcst" in url:
return self._kma([{"regId": params["regId"], "wf4Am": "맑음", "wf4Pm": "구름많음",
"rnSt4Am": 10, "rnSt4Pm": 20, "wf5Am": "흐림", "wf5Pm": "흐리고 비",
"rnSt5Am": 30, "rnSt5Pm": 60, "wf10": "맑음", "rnSt10": 10}])
raise AssertionError(url)
assert "api.open-meteo.com/v1/forecast" in url, url
return self._ok({"current": {"temperature_2m": 11.0, "weather_code": 0}, "daily": {
"time": [f"2026-11-{d}" for d in range(18, 29)],
"weather_code": [0, 61, 3, 2, 0, 0, 0, 0, 0, 0, 0],
"temperature_2m_min": [1.2, 2.6, 0, 0, 0, 0, 0, 0, 0, 0, 0],
"temperature_2m_max": [9.0, 11.4, 0, 0, 0, 0, 0, 0, 0, 0, 0],
"precipitation_probability_max": [0, 80, 0, 0, 0, 0, 0, 0, 0, 0, 0],
"wind_speed_10m_max": [9.0, 18.0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
"precipitation_sum": [0.0, 12.5, 0, 0, 0, 0, 0, 0, 0, 0, 0],
}})
return get
def _run(self, args, monkeypatch, key=True, now=None, **routes):
if key:
monkeypatch.setenv("JARVIS_KMA_API_KEY", self.KEY)
else:
monkeypatch.delenv("JARVIS_KMA_API_KEY", raising=False)
calls = []
with patch('requests.get', side_effect=self._routes(calls=calls, **routes)), \
patch('src.jarvis.tools.builtin.weather._now', return_value=now or self.NOW):
result = self.tool.run({"location": "Seoul", **args}, self.context)
return result, calls
def test_the_schema_offers_a_later_day_and_a_span_of_days(self):
props = self.tool.inputSchema["properties"]
assert props["days_ahead"]["type"] == "integer" and props["days"]["type"] == "integer"
assert self.tool.inputSchema["required"] == []
def test_tomorrow_in_korea_comes_from_the_kma_short_term_forecast(self, monkeypatch):
result, calls = self._run({"days_ahead": 1}, monkeypatch)
assert result.success is True
text = result.reply_text
assert text.startswith("내일(11월 19일 목요일) Seoul 날씨는")
assert "오전 맑음" in text and "오후 비" in text
assert "최저 -1도" in text and "최고 4도" in text and "강수확률 60%" in text
assert not any("open-meteo.com/v1/forecast" in u for u, _ in calls)
vilage = [p for u, p in calls if "getVilageFcst" in u]
assert len(vilage) == 1 and vilage[0]["authKey"] == self.KEY
assert (vilage[0]["nx"], vilage[0]["ny"]) == (60, 127)
assert (vilage[0]["base_date"], vilage[0]["base_time"]) == ("20261118", "0800")
assert not any("MidFcstInfoService" in u for u, _ in calls)
def test_five_days_ahead_in_korea_comes_from_the_kma_mid_term_forecast(self, monkeypatch):
result, calls = self._run({"days_ahead": 5}, monkeypatch)
text = result.reply_text
assert text.startswith("11월 23일 월요일 Seoul 날씨는")
assert "오전 흐림" in text and "오후 흐리고 비" in text
assert "최저 -2도" in text and "최고 7도" in text and "강수확률 60%" in text
mid = {u.rsplit("/", 1)[-1]: p for u, p in calls if "MidFcstInfoService" in u}
assert mid["getMidTa"]["regId"] == "11B10101" and mid["getMidLandFcst"]["regId"] == "11B00000"
assert mid["getMidTa"]["tmFc"] == "202611180600" and mid["getMidTa"]["authKey"] == self.KEY
assert not any("getVilageFcst" in u for u, _ in calls)
def test_the_weekend_spans_the_short_and_mid_term_forecasts(self, monkeypatch):
result, _ = self._run({"days_ahead": 3, "days": 2}, monkeypatch)
lines = result.reply_text.split("\n")
assert len(lines) == 2
assert lines[0].startswith("11월 21일 토요일") and "흐림" in lines[0] and "강수확률 30%" in lines[0]
assert lines[1].startswith("11월 22일 일요일") and "오전 맑음" in lines[1] and "오후 구름많음" in lines[1]
assert "최저 -4도" in lines[1] and "최고 5도" in lines[1]
def test_the_same_weather_all_day_is_said_once(self, monkeypatch):
result, _ = self._run({"days_ahead": 2}, monkeypatch)
assert result.reply_text.startswith("모레(11월 20일 금요일) Seoul 날씨는 구름 많음,")
assert "오전" not in result.reply_text
@pytest.mark.parametrize("lat,lon,city,region", [
(35.1796, 129.0756, "11H20201", "11H20000"), # 부산
(33.4996, 126.5312, "11G00201", "11G00000"), # 제주
(35.9676, 126.7369, "21F10501", "11F10000"), # 군산
(37.7519, 128.8761, "11D20501", "11D20000"), # 강릉
])
def test_the_mid_term_forecast_is_for_the_nearest_kma_city_and_its_region(
self, lat, lon, city, region, monkeypatch):
_, calls = self._run({"days_ahead": 6}, monkeypatch, lat=lat, lon=lon)
mid = {u.rsplit("/", 1)[-1]: p for u, p in calls if "MidFcstInfoService" in u}
assert mid["getMidTa"]["regId"] == city and mid["getMidLandFcst"]["regId"] == region
@pytest.mark.parametrize("now,vilage,tmfc", [
(datetime(2026, 11, 18, 1, 50), ("20261117", "2300"), "202611171800"),
(datetime(2026, 11, 18, 2, 20), ("20261118", "0200"), "202611171800"),
(datetime(2026, 11, 18, 6, 40), ("20261118", "0500"), "202611180600"),
(datetime(2026, 11, 18, 23, 59), ("20261118", "2300"), "202611181800"),
])
def test_kma_forecasts_are_the_latest_published(self, now, vilage, tmfc, monkeypatch):
"""단기예보 is out about 10 minutes after 02, 05, ..., 23 h; 중기예보 about 30 minutes after 06 and 18 h."""
now = now.replace(tzinfo=timezone(timedelta(hours=9)))
_, calls = self._run({"days_ahead": 1}, monkeypatch, now=now)
_, mid_calls = self._run({"days_ahead": 7}, monkeypatch, now=now)
(p,) = [p for u, p in calls if "getVilageFcst" in u]
assert (p["base_date"], p["base_time"]) == vilage
assert {p["tmFc"] for u, p in mid_calls if "MidFcstInfoService" in u} == {tmfc}
def test_an_evening_mid_term_forecast_from_yesterday_counts_its_days_from_yesterday(self, monkeypatch):
# 05:00 on the 19th: the latest 중기예보 is the 18th's 18:00, whose day 5 is the 23rd = 4 days ahead.
now = datetime(2026, 11, 19, 5, 0, tzinfo=timezone(timedelta(hours=9)))
result, _ = self._run({"days_ahead": 4}, monkeypatch, now=now)
assert result.reply_text.startswith("11월 23일 월요일") and "최고 7도" in result.reply_text
def test_when_kma_fails_open_meteo_gives_the_forecast_and_the_key_is_not_logged(self, monkeypatch):
with patch("src.jarvis.tools.builtin.weather.debug_log") as log:
result, calls = self._run({"days_ahead": 1}, monkeypatch, fail_kma=True)
assert result.success is True
assert result.reply_text.startswith("내일(11월 19일 목요일) Seoul 날씨는 약한 비,")
assert "최저 3도" in result.reply_text and "최고 11도" in result.reply_text
assert "강수확률 80%" in result.reply_text
assert not any(self.KEY in str(c) for c in log.call_args_list)
@pytest.mark.parametrize("fail_kma, counts", [(False, "1 from KMA, 0 from open-meteo"),
(True, "0 from KMA, 1 from open-meteo")])
def test_the_log_says_how_many_forecast_days_each_service_gave(self, fail_kma, counts, monkeypatch, capfd):
self._run({"days_ahead": 1}, monkeypatch, fail_kma=fail_kma)
err = capfd.readouterr().err
assert f"weather days 1-1: {counts}" in err
assert "Seoul" not in err and self.KEY not in err
def test_outside_korea_the_forecast_is_open_meteos_daily_one(self, monkeypatch):
result, calls = self._run({"days_ahead": 1}, monkeypatch, country_code="JP")
assert "약한 비" in result.reply_text and "최고 11도" in result.reply_text
assert not any("apihub.kma.go.kr" in u for u, _ in calls)
(p,) = [p for u, p in calls if "open-meteo.com/v1/forecast" in u]
assert "precipitation_probability_max" in p["daily"] and p["forecast_days"] >= 2
def test_this_week_starts_with_the_weather_now(self, monkeypatch):
"""days_ahead 0 with more days: the current weather, then a line for each day."""
result, _ = self._run({"days": 3}, monkeypatch, key=False)
lines = result.reply_text.split("\n")
assert lines[0].startswith("지금 Seoul 날씨는")
assert lines[1].startswith("오늘(11월 18일 수요일)") and lines[2].startswith("내일(11월 19일 목요일)")
assert lines[3].startswith("모레(11월 20일 금요일)") and len(lines) == 4
def test_more_than_ten_days_ahead_is_the_tenth_day(self, monkeypatch):
result, _ = self._run({"days_ahead": 30, "days": 5}, monkeypatch)
assert result.reply_text.split("\n") == [result.reply_text]
assert result.reply_text.startswith("11월 28일 토요일") and "맑음" in result.reply_text
def test_when_no_forecast_is_available_the_answer_says_so(self, monkeypatch):
def down(url, *a, **k):
if "geocoding" in url:
return self._ok({"results": [{"latitude": 1.0, "longitude": 2.0, "name": "X",
"country_code": "FR"}]})
raise requests.exceptions.ConnectionError("down")
with patch('requests.get', side_effect=down), \
patch('src.jarvis.tools.builtin.weather._now', return_value=self.NOW):
result = self.tool.run({"location": "X", "days_ahead": 2}, self.context)
assert result.success is False and "forecast" in result.reply_text.lower()
# 단기예보's 소나기 (PTY 4) and the detail a person asks for on a later day.
def test_short_term_showers_are_said_not_dropped_for_a_clear_sky(self, monkeypatch):
items = [{"category": c, "fcstDate": "20261119", "fcstTime": f"{h:02d}00", "fcstValue": v}
for h in range(24) for c, v in
[("SKY", "1"), ("PTY", "4" if h >= 12 else "0"), ("POP", "60" if h >= 12 else "0"),
("TMP", "5")]]
items += [{"category": "TMN", "fcstDate": "20261119", "fcstTime": "0600", "fcstValue": "-1.0"},
{"category": "TMX", "fcstDate": "20261119", "fcstTime": "1500", "fcstValue": "4.0"}]
with patch.object(TestForecast, "_vilage_items", staticmethod(lambda: items)):
result, _ = self._run({"days_ahead": 1}, monkeypatch)
assert "오전 맑음, 오후 소나기" in result.reply_text, result.reply_text
def test_asked_in_detail_the_short_term_day_has_humidity_and_the_strongest_wind(self, monkeypatch):
result, _ = self._run({"days_ahead": 1, "detail": True}, monkeypatch)
assert "습도 70%" in result.reply_text and "최대 바람 초속 4미터" in result.reply_text
def test_asked_in_detail_open_meteos_day_has_the_strongest_wind_and_the_rain(self, monkeypatch):
result, calls = self._run({"days_ahead": 1, "detail": True}, monkeypatch, country_code="JP")
(p,) = [p for u, p in calls if "open-meteo.com/v1/forecast" in u]
assert {"wind_speed_10m_max", "precipitation_sum"} <= set(p["daily"].split(","))
assert "최대 바람 초속 5미터" in result.reply_text and "강수량 12.5mm" in result.reply_text
def test_the_schema_offers_detail(self):
assert self.tool.inputSchema["properties"]["detail"]["type"] == "boolean"
class TestDistrictPlaces:
"""A district such as 부산 연제구 is found by OpenStreetMap's search (any language) when
open-meteo's geocoder, which knows cities only, does not find it; the weather is for that spot."""
KEY = "kma-test-key-123"
def setup_method(self):
self.tool = WeatherTool()
self.context = Mock(spec=ToolContext)
self.context.user_print = Mock()
self.context.cfg = Mock()
self.context.cfg.location_name = None
self.context.redacted_text = ""
@staticmethod
def _ok(payload):
r = Mock(status_code=200, raise_for_status=Mock())
r.json.return_value = payload
return r
def _routes(self, calls, osm=None, osm_fails=False):
def get(url, *a, **k):
params = k.get("params") or {}
calls.append((url, params, k.get("headers") or {}))
if "geocoding-api.open-meteo.com" in url:
return self._ok({})
if "nominatim.openstreetmap.org" in url:
if osm_fails:
raise requests.exceptions.Timeout("timed out")
return self._ok(osm if osm is not None else [{
"lat": "35.1762", "lon": "129.0797", "name": "연제구", "addresstype": "borough",
"address": {"borough": "연제구", "city": "부산광역시", "country_code": "kr"}}])
if "getUltraSrtNcst" in url:
return self._ok({"response": {"header": {"resultCode": "00"}, "body": {"items": {"item": [
{"category": c, "obsrValue": v} for c, v in
[("PTY", "0"), ("REH", "60"), ("T1H", "8.2"), ("WSD", "3.1")]]}}}})
if "getUltraSrtFcst" in url:
return self._ok({"response": {"header": {"resultCode": "00"}, "body": {"items": {"item": [
{"category": "SKY", "fcstDate": "20261118", "fcstTime": "1200", "fcstValue": "1"}]}}}})
assert "api.open-meteo.com/v1/forecast" in url, url
return self._ok({"current": {"temperature_2m": 11.0, "weather_code": 0}})
return get
@patch('src.jarvis.tools.builtin.weather._romanise_place')
def test_a_district_gets_its_own_spots_weather_from_kma(self, mock_romanise, monkeypatch):
from src.jarvis.tools.builtin.weather import _kma_grid
monkeypatch.setenv("JARVIS_KMA_API_KEY", self.KEY)
calls = []
with patch('requests.get', side_effect=self._routes(calls)):
result = self.tool.run({"location": "부산 연제구"}, self.context)
assert result.success is True
assert result.reply_text.startswith("지금 부산 연제구 날씨는 맑음") and "기온 8도" in result.reply_text
kma = [p for u, p, _ in calls if "apihub.kma.go.kr" in u]
assert kma and all((p["nx"], p["ny"]) == _kma_grid(35.1762, 129.0797) for p in kma)
mock_romanise.assert_not_called()
def test_the_place_search_asks_for_one_place_with_its_country_and_names_the_app(self, monkeypatch):
monkeypatch.delenv("JARVIS_KMA_API_KEY", raising=False)
calls = []
with patch('requests.get', side_effect=self._routes(calls)):
self.tool.run({"location": "부산 연제구"}, self.context)
((_, params, headers),) = [c for c in calls if "nominatim.openstreetmap.org" in c[0]]
assert params["q"] == "부산 연제구" and params["limit"] == 1 and params["addressdetails"] == 1
assert "jarvis" in headers.get("User-Agent", "").lower()
@pytest.mark.parametrize("osm,osm_fails", [([], False), (None, True), ({"error": "x"}, False)])
@patch('src.jarvis.tools.builtin.weather._romanise_place', return_value=None)
def test_when_the_place_search_finds_nothing_or_fails_the_place_is_not_found(
self, _rom, osm, osm_fails, monkeypatch):
monkeypatch.delenv("JARVIS_KMA_API_KEY", raising=False)
calls = []
with patch('requests.get', side_effect=self._routes(calls, osm=osm, osm_fails=osm_fails)):
result = self.tool.run({"location": "없는 동네"}, self.context)
assert result.success is False and "could not find" in result.reply_text.lower()
@patch('src.jarvis.tools.builtin.weather._romanise_place')
def test_a_non_latin_city_name_is_not_matched_loosely_by_open_meteo(self, mock_romanise, monkeypatch):
"""Live 2026-11-18: open-meteo matched "부산" to a village called Pusan 140 km from Busan."""
monkeypatch.delenv("JARVIS_KMA_API_KEY", raising=False)
calls = []
osm = [{"lat": "35.1799", "lon": "129.0752", "name": "부산광역시", "address": {"country_code": "kr"}}]
with patch('requests.get', side_effect=self._routes(calls, osm=osm)):
result = self.tool.run({"location": "부산"}, self.context)
assert result.reply_text.startswith("지금 부산 날씨는")
assert not any("geocoding-api.open-meteo.com" in u for u, _, _ in calls)
(_, p, _), = [c for c in calls if "api.open-meteo.com/v1/forecast" in c[0]]
assert (p["latitude"], p["longitude"]) == (35.1799, 129.0752)
mock_romanise.assert_not_called()
def test_a_latin_name_open_meteo_knows_does_not_ask_openstreetmap(self, monkeypatch):
monkeypatch.delenv("JARVIS_KMA_API_KEY", raising=False)
calls = []
base = self._routes(calls)
def get(url, *a, **k):
if "geocoding-api.open-meteo.com" in url:
calls.append((url, k.get("params"), {}))
return self._ok({"results": [{"latitude": 51.5, "longitude": -0.12, "name": "London",
"country_code": "GB"}]})
return base(url, *a, **k)
with patch('requests.get', side_effect=get):
result = self.tool.run({"location": "London"}, self.context)
assert result.success and not any("nominatim" in u for u, _, _ in calls)
def test_the_day_schema_gives_each_coming_weekdays_days_ahead_from_today():
"""The model is handed the count instead of working it out (qwen3:8b counted a Wednesday's weekend as 2)."""
today = datetime.now()
text = WeatherTool().inputSchema["properties"]["days_ahead"]["description"]
saturday = (5 - today.weekday()) % 7 or 7
assert f"From today, {today.strftime('%A')}:" in text
assert f"{(today + timedelta(days=saturday)).strftime('%A')} {saturday}" in text