系统与运行
Runtime
+
定时任务
会话监控
工作区路径
附件
diff --git a/interfaces/gateway/context_builder.py b/interfaces/gateway/context_builder.py
index 5df33b16..f80c9d51 100644
--- a/interfaces/gateway/context_builder.py
+++ b/interfaces/gateway/context_builder.py
@@ -5,6 +5,7 @@ from typing import Any
from runtime.skill_installer import install_skill_from_registry_archive
from runtime.tools.skills.clawhub_client import get_skill_detail as clawhub_get_skill_detail
from runtime.tools.skills.clawhub_client import search_skills as clawhub_search_skills
+from runtime.scheduler.cron_service import CronService
def build_common_gateway_context(*, store: Any) -> dict[str, Any]:
@@ -80,6 +81,7 @@ def build_common_gateway_context(*, store: Any) -> dict[str, Any]:
return {
"store": store,
+ "cron": CronService(store=store),
"search_clawhub_skills": _search_clawhub_skills,
"fetch_clawhub_skill_detail": _fetch_clawhub_skill_detail,
"install_skill_from_clawhub": _install_skill_from_clawhub,
diff --git a/interfaces/gateway/dispatcher.py b/interfaces/gateway/dispatcher.py
index 39cc848c..60c64ad6 100644
--- a/interfaces/gateway/dispatcher.py
+++ b/interfaces/gateway/dispatcher.py
@@ -4,6 +4,7 @@ from interfaces.gateway.server_methods.agent import agent_handlers
from interfaces.gateway.server_methods.chat import chat_handlers
from interfaces.gateway.server_methods.commands import commands_handlers
from interfaces.gateway.server_methods.connect import connect_handlers
+from interfaces.gateway.server_methods.cron import cron_handlers
from interfaces.gateway.server_methods.sessions import sessions_handlers
from interfaces.gateway.server_methods.skills import skills_handlers
from interfaces.gateway.server_methods.shared_types import GatewayRequestHandlers
@@ -19,6 +20,7 @@ def build_gateway_method_handlers() -> GatewayRequestHandlers:
sessions_handlers,
skills_handlers,
agent_handlers,
+ cron_handlers,
):
for method, handler in (group or {}).items():
merged[str(method)] = handler
diff --git a/interfaces/gateway/server_methods/cron.py b/interfaces/gateway/server_methods/cron.py
index 9fe59ad2..fa5c2536 100644
--- a/interfaces/gateway/server_methods/cron.py
+++ b/interfaces/gateway/server_methods/cron.py
@@ -70,6 +70,8 @@ def _cron_list_handler(opts: dict[str, Any]) -> None:
"enabled": params.get("enabled"),
"sortBy": params.get("sortBy"),
"sortDir": params.get("sortDir"),
+ "tenantId": params.get("tenantId"),
+ "tenant_id": params.get("tenant_id"),
}
),
)
diff --git a/interfaces/http/fastapi_app.py b/interfaces/http/fastapi_app.py
index a99e8510..c83fd870 100644
--- a/interfaces/http/fastapi_app.py
+++ b/interfaces/http/fastapi_app.py
@@ -217,6 +217,15 @@ def _run_startup_hooks(app: FastAPI) -> None:
_log_info(f"[startup-prebuild] scheduler_started interval_s={_prewarm_interval_seconds()}")
except Exception as exc:
_log_warn(f"[startup-prebuild] scheduler_start_failed: {exc}")
+ try:
+ from svc.persistence.assistant_store import get_assistant_store
+ from runtime.scheduler.service import ensure_scheduler_started
+
+ store = get_assistant_store()
+ sid = ensure_scheduler_started(store=store)
+ _log_info(f"[scheduled-jobs] scheduler_started thread={sid}")
+ except Exception as exc:
+ _log_warn(f"[scheduled-jobs] scheduler_start_failed: {exc}")
_relocate_root_scan_artifacts()
startup_targets = _resolve_startup_workspace_dirs(cfg)
initialize_hooks_runtime(cfg=cfg, workspace_dir=startup_targets[0][1])
@@ -302,6 +311,31 @@ def create_app() -> FastAPI:
changed = store.ack_channel_outbound_message(message_id=msg_id, ok=ok, error=err)
return {"ok": changed}
+ @app.get("/weixin/outbound/pending")
+ def weixin_outbound_pending(account_id: str = "", limit: int = 20) -> dict[str, Any]:
+ from svc.persistence.assistant_store import get_assistant_store
+
+ store = get_assistant_store()
+ lister = getattr(store, "list_pending_weixin_outbound_messages", None)
+ if not callable(lister):
+ return {"ok": True, "items": []}
+ items = lister(account_id=str(account_id or "").strip(), limit=limit)
+ return {"ok": True, "items": items}
+
+ @app.post("/weixin/outbound/ack")
+ def weixin_outbound_ack(payload: dict[str, Any]) -> dict[str, Any]:
+ from svc.persistence.assistant_store import get_assistant_store
+
+ body = payload if isinstance(payload, dict) else {}
+ msg_id = str(body.get("id") or "").strip()
+ if not msg_id:
+ return {"ok": False, "error": "missing id"}
+ ok = bool(body.get("ok", True))
+ err = str(body.get("error") or "").strip()
+ store = get_assistant_store()
+ changed = store.ack_channel_outbound_message(message_id=msg_id, ok=ok, error=err)
+ return {"ok": changed}
+
@app.post("/wecom/inbound")
async def wecom_inbound(payload: dict[str, Any]) -> dict[str, Any]:
payload = payload if isinstance(payload, dict) else {}
diff --git a/interfaces/http/weixin_ilink_api.py b/interfaces/http/weixin_ilink_api.py
index 30ae8240..7b037637 100644
--- a/interfaces/http/weixin_ilink_api.py
+++ b/interfaces/http/weixin_ilink_api.py
@@ -262,12 +262,23 @@ class _IlinkBridge:
if eid <= cursor:
continue
if str(event.get("token") or "") != token:
- continue
+ ev_tok = str(event.get("token") or "")
+ if ev_tok and ev_tok not in ("default", token):
+ continue
payload = event.get("payload") if isinstance(event.get("payload"), dict) else {}
if channel and str(payload.get("channel") or "") != channel:
- continue
- if account_id and str(payload.get("account_id") or "") != account_id:
- continue
+ alt = {"wechat", "weixin"}
+ if not (
+ channel in alt
+ and str(payload.get("channel") or "") in alt
+ ):
+ continue
+ req_acct = str(account_id or "").strip()
+ pay_acct = str(payload.get("account_id") or "").strip()
+ if req_acct and pay_acct and pay_acct != req_acct:
+ legacy = {"", "weixin-default"}
+ if pay_acct not in legacy and req_acct not in legacy:
+ continue
next_cursor = max(next_cursor, eid)
item = dict(payload)
item["id"] = str(eid)
@@ -319,6 +330,23 @@ async def _process_inbound_and_enqueue(
return ""
+ ctx_token = _extract_context_token(payload)
+ try:
+ from runtime.scheduler.channel_delivery import persist_channel_context_token
+ from svc.persistence.assistant_store import get_assistant_store
+
+ store = get_assistant_store()
+ persist_channel_context_token(
+ store,
+ tenant_id=str(payload.get("tenant_id") or ""),
+ channel=channel,
+ account_id=account_id,
+ external_chat_id=str(chat_id or user_id or ""),
+ context_token=ctx_token,
+ )
+ except Exception:
+ pass
+
try:
out = await asyncio.wait_for(asyncio.to_thread(_process_inbound_payload_usecase, payload), timeout=60.0)
except asyncio.TimeoutError:
@@ -534,5 +562,32 @@ async def whatsapp_native_reply(
}
-__all__ = ["router"]
+def enqueue_weixin_outbound_reply(
+ *,
+ channel: str,
+ account_id: str,
+ chat_id: str,
+ text: str,
+ context_token: str = "",
+ token: str = "",
+) -> str:
+ """Enqueue a proactive Weixin/WeChat outbound message for the sidecar poll loop."""
+ tok = str(
+ token or os.getenv("AIA_WEIXIN_ILINK_TOKEN") or os.getenv("AIA_ILINK_TOKEN") or "default"
+ ).strip()
+ ch = str(channel or "wechat").strip().lower()
+ if ch == "weixin":
+ ch = "wechat"
+ _BRIDGE.enqueue_reply(
+ token=tok,
+ channel=ch,
+ account_id=str(account_id or "").strip(),
+ chat_id=str(chat_id or "").strip(),
+ text=str(text or ""),
+ context_token=str(context_token or "").strip(),
+ )
+ return str(_BRIDGE._seq)
+
+
+__all__ = ["router", "enqueue_weixin_outbound_reply"]
diff --git a/requirements.txt b/requirements.txt
index 24cb7787..db3a758f 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -21,3 +21,4 @@ python-dotenv>=1.0.0
sqlalchemy>=2.0.0
psycopg[binary]>=3.1.0
alembic>=1.13.0
+croniter>=2.0.0
diff --git a/runtime/agent_core_attempt.py b/runtime/agent_core_attempt.py
index 06dc1e80..2788923a 100644
--- a/runtime/agent_core_attempt.py
+++ b/runtime/agent_core_attempt.py
@@ -161,8 +161,18 @@ def run_attempt(*, store: Any, data: AttemptRunnerInput) -> AttemptRunnerOutput:
on_tool_ui=data.on_tool_ui,
should_stop=data.should_stop,
workspace_owner_session_id=_workspace_owner_session_id_from_msg(data.msg),
- path_policy_tenant_id=str(data.msg.metadata.get("tenant_id") or "") if isinstance(data.msg.metadata, dict) else None,
- path_policy_user_id=str(data.msg.metadata.get("user_id") or "") if isinstance(data.msg.metadata, dict) else None,
+ path_policy_tenant_id=str(data.msg.tenant_id or "")
+ or (
+ str(data.msg.metadata.get("tenant_id") or "")
+ if isinstance(data.msg.metadata, dict)
+ else ""
+ ),
+ path_policy_user_id=str(data.msg.user_id or "")
+ or (
+ str(data.msg.metadata.get("user_id") or "")
+ if isinstance(data.msg.metadata, dict)
+ else ""
+ ),
workspace_dir=data.workspace_dir,
memory_context=data.memory_context,
persist_user_message=bool(data.persist_user_message),
diff --git a/runtime/agent_core_run.py b/runtime/agent_core_run.py
index 9b1958d5..16c77aaa 100644
--- a/runtime/agent_core_run.py
+++ b/runtime/agent_core_run.py
@@ -48,6 +48,7 @@ class AgentCoreRunInput:
skill_binding_role: str | None = None
wire_policy_role: str | None = None
persisted_user_text: str | None = None
+ persist_user_message: bool = True
@dataclass(frozen=True)
@@ -204,7 +205,7 @@ def run_agent_core(*, store: Any, data: AgentCoreRunInput) -> AgentCoreRunOutput
max_tool_rounds=data.max_tool_rounds,
max_tool_workers=data.max_tool_workers,
memory_context=mem_ctx,
- persist_user_message=(idx == 1),
+ persist_user_message=(idx == 1 and bool(data.persist_user_message)),
on_token=data.on_token,
on_progress=data.on_progress,
on_tool_ui=data.on_tool_ui,
diff --git a/runtime/application/gateway/inbound_service.py b/runtime/application/gateway/inbound_service.py
index 927a5f8e..cde774df 100644
--- a/runtime/application/gateway/inbound_service.py
+++ b/runtime/application/gateway/inbound_service.py
@@ -103,7 +103,7 @@ def _menu_text() -> str:
)
-def _handle_productivity_commands(*, text: str, tenant_id: str, user_id: str) -> str | None:
+def _handle_productivity_commands(*, text: str, tenant_id: str, user_id: str, session_id: str = "") -> str | None:
t = (text or "").strip()
if not t:
return None
@@ -175,9 +175,88 @@ def _handle_productivity_commands(*, text: str, tenant_id: str, user_id: str) ->
lines = [f"- {str(h.get('source') or '')}: {str(h.get('snippet') or '')}" for h in hits[:5] if isinstance(h, dict)]
return "知识检索结果：\n" + "\n".join(lines)
+ if t in ("查定时任务", "定时任务", "schedules", "/schedule list"):
+ rows = store.scheduled_job_list(tenant_id=tenant_id, status=None, limit=10)
+ if not rows:
+ return "当前没有定时任务。"
+ lines = [
+ f"- {r.name} | {r.schedule_kind}:{r.schedule_expr} | {r.status} | id={r.id[:8]}"
+ for r in rows
+ ]
+ return "定时任务：\n" + "\n".join(lines)
+
+ if t.startswith("暂停定时任务 ") or t.startswith("暂停定时 "):
+ prefix = "暂停定时任务 " if t.startswith("暂停定时任务 ") else "暂停定时 "
+ jid = t[len(prefix) :].strip()
+ if not jid:
+ return "请提供任务 id 前缀。示例：暂停定时任务 1234abcd"
+ rows = store.scheduled_job_list(tenant_id=tenant_id, status=None, limit=200)
+ full = next((r.id for r in rows if str(r.id).startswith(jid)), jid)
+ ok = store.scheduled_job_set_status(tenant_id=tenant_id, job_id=full, status="paused")
+ return "已暂停。" if ok else "未找到该定时任务。"
+
+ if t.startswith("删除定时任务 ") or t.startswith("删除定时 "):
+ prefix = "删除定时任务 " if t.startswith("删除定时任务 ") else "删除定时 "
+ jid = t[len(prefix) :].strip()
+ if not jid:
+ return "请提供任务 id 前缀。示例：删除定时任务 1234abcd"
+ rows = store.scheduled_job_list(tenant_id=tenant_id, status=None, limit=200)
+ full = next((r.id for r in rows if str(r.id).startswith(jid)), jid)
+ ok = store.scheduled_job_delete(tenant_id=tenant_id, job_id=full)
+ return "已删除。" if ok else "未找到该定时任务。"
+
+ if t.startswith("记定时 ") or t.startswith("创建定时 "):
+ body = t.split(" ", 1)[1].strip() if " " in t else ""
+ parts = body.split(None, 1)
+ if len(parts) < 2:
+ return "格式：记定时 <时间> <提醒内容>。示例：记定时 5分钟 提醒我休息"
+ when_raw, prompt_text = parts[0].strip(), parts[1].strip()
+ seconds = _parse_schedule_duration_seconds(when_raw)
+ if seconds <= 0:
+ return "无法识别时间。示例：5分钟、1小时、300秒"
+ from runtime.scheduler.cron_service import build_delivery_for_session
+
+ delivery = build_delivery_for_session(
+ store,
+ tenant_id=tenant_id,
+ session_id=str(session_id or "").strip(),
+ )
+ row = store.scheduled_job_create(
+ tenant_id=tenant_id,
+ name=prompt_text[:40] or "定时提醒",
+ prompt_text=prompt_text,
+ schedule_kind="interval",
+ schedule_expr=str(seconds),
+ delivery=delivery,
+ source_session_id=str(session_id or "").strip() or None,
+ created_by_user_id=user_id,
+ source="chat",
+ )
+ return f"已创建定时任务：{row.id[:8]} | {prompt_text} | 每 {seconds} 秒"
+
return None
+def _parse_schedule_duration_seconds(raw: str) -> int:
+ import re
+
+ text = str(raw or "").strip().lower()
+ if not text:
+ return 0
+ if text.isdigit():
+ return max(1, int(text))
+ m = re.match(r"^(\d+(?:\.\d+)?)\s*(秒|s|sec|secs|second|seconds|分钟|分|min|mins|小时|时|h|hr|hrs|hour|hours)$", text)
+ if not m:
+ return 0
+ val = float(m.group(1))
+ unit = m.group(2)
+ if unit in {"秒", "s", "sec", "secs", "second", "seconds"}:
+ return max(1, int(val))
+ if unit in {"分钟", "分", "min", "mins"}:
+ return max(1, int(val * 60))
+ return max(1, int(val * 3600))
+
+
def _role_can_write(role: str, text: str) -> bool:
low = (text or "").strip().lower()
if not low:
@@ -810,6 +889,24 @@ def process_inbound_payload(payload: dict[str, Any]) -> dict[str, Any]:
)
channel_session_id = str(session_id)
store.ensure_ui_session_owner(session_id=session_id, tenant_id=tenant_id, user_id=user_id)
+ if str(inbound.channel or "").strip().lower() in {"wechat", "weixin"}:
+ from runtime.scheduler.channel_delivery import (
+ extract_context_token_from_inbound_metadata,
+ persist_channel_context_token,
+ )
+
+ ctx_tok = extract_context_token_from_inbound_metadata(
+ inbound.metadata if isinstance(inbound.metadata, dict) else None
+ )
+ if ctx_tok:
+ persist_channel_context_token(
+ store,
+ tenant_id=tenant_id,
+ channel=str(inbound.channel or "weixin"),
+ account_id=account_id,
+ external_chat_id=str(inbound.external_chat_id or inbound.external_user_id or ""),
+ context_token=ctx_tok,
+ )
scope = "group" if inbound.is_group else "direct"
pe = PolicyEngine()
blob = (inbound.text or "").lower()
@@ -842,6 +939,7 @@ def process_inbound_payload(payload: dict[str, Any]) -> dict[str, Any]:
text=inbound.text,
tenant_id=tenant_id,
user_id=user_id,
+ session_id=str(session_id),
)
if cmd_reply is not None:
reply = cmd_reply
diff --git a/runtime/chat/tool_runtime.py b/runtime/chat/tool_runtime.py
index bde44747..da8fee2e 100644
--- a/runtime/chat/tool_runtime.py
+++ b/runtime/chat/tool_runtime.py
@@ -493,7 +493,21 @@ class ToolExecutor:
msg = f"Unregistered tool: {tc.name}" if ctx.lang.startswith("en") else f"未注册的工具: {tc.name}"
return {"ok": False, "error_code": "tool_not_registered", "error": msg}, int((time.perf_counter() - t0) * 1000)
- ok, v_err = validate_tool_arguments(tool.parameters, tc.arguments)
+ from runtime.tools.context_inject import enrich_tool_arguments
+ from runtime.tools.tool_validation import filter_arguments_to_schema
+
+ raw_args = tc.arguments if isinstance(tc.arguments, dict) else {}
+ tool_args = enrich_tool_arguments(
+ store=ctx.store,
+ session_id=ctx.session_id,
+ tool_name=str(tc.name or ""),
+ arguments=raw_args,
+ path_policy_tenant_id=ctx.path_policy_tenant_id,
+ path_policy_user_id=ctx.path_policy_user_id,
+ )
+ tool_args = filter_arguments_to_schema(tool.parameters, tool_args)
+
+ ok, v_err = validate_tool_arguments(tool.parameters, tool_args)
if not ok:
msg = f"Invalid arguments: {v_err}" if ctx.lang.startswith("en") else f"参数不合法: {v_err}"
return {"ok": False, "error_code": "tool_invalid_arguments", "error": msg}, int((time.perf_counter() - t0) * 1000)
@@ -530,7 +544,7 @@ class ToolExecutor:
netx_lang_token = NETX_TOOL_LANG.set(str(ctx.lang or "zh"))
try:
- return tool.handler(tc.arguments)
+ return tool.handler(tool_args)
finally:
if netx_lang_token is not None:
from runtime.tools.experts.network_ops.netx_tools import NETX_TOOL_LANG
diff --git a/runtime/direct_loop.py b/runtime/direct_loop.py
index 6c23e46b..e9df7bec 100644
--- a/runtime/direct_loop.py
+++ b/runtime/direct_loop.py
@@ -690,6 +690,14 @@ def _build_model_context(
)
except Exception:
pass
+ if str(user_text or "").strip() and str(active_turn_uuid or "").strip():
+ has_turn_user = any(
+ str(getattr(m, "role", "") or "") == "user"
+ and str(getattr(m, "turn_uuid", "") or "") == str(active_turn_uuid)
+ for m in (rows or [])
+ )
+ if not has_turn_user:
+ llm_messages.append({"role": "user", "content": str(user_text).strip()})
return llm_messages
diff --git a/runtime/operations/weixin_bridge/official_runner.ts b/runtime/operations/weixin_bridge/official_runner.ts
index aadd95a8..e03710c1 100644
--- a/runtime/operations/weixin_bridge/official_runner.ts
+++ b/runtime/operations/weixin_bridge/official_runner.ts
@@ -192,6 +192,154 @@ function resolveHeaders(token: string): Record
{
};
}
+async function postLocalJson(token: string, route: string, body: Json, timeoutMs = 8000): Promise {
+ const url = `${LOCAL_BASE_URL.replace(/\/+$/, "")}/${route.replace(/^\/+/, "")}`;
+ const res = await fetch(url, {
+ method: "POST",
+ headers: resolveHeaders(token),
+ body: JSON.stringify(body),
+ signal: AbortSignal.timeout(timeoutMs),
+ });
+ const text = await res.text();
+ if (!res.ok) {
+ throw new HttpStatusError(res.status, `${route} ${res.status}: ${text.slice(0, 300)}`);
+ }
+ return text ? (JSON.parse(text) as Json) : {};
+}
+
+async function getLocalJson(token: string, route: string, timeoutMs = 8000): Promise {
+ const url = `${LOCAL_BASE_URL.replace(/\/+$/, "")}/${route.replace(/^\/+/, "")}`;
+ const res = await fetch(url, {
+ method: "GET",
+ headers: resolveHeaders(token),
+ signal: AbortSignal.timeout(timeoutMs),
+ });
+ const text = await res.text();
+ if (!res.ok) {
+ throw new HttpStatusError(res.status, `${route} ${res.status}: ${text.slice(0, 300)}`);
+ }
+ return text ? (JSON.parse(text) as Json) : {};
+}
+
+async function flushWeixinDbOutbound(args: {
+ modules: OfficialModules;
+ token: string;
+ accountId: string;
+ cloudBaseUrl: string;
+ userContextTokens: TokenMap;
+}): Promise {
+ const q = encodeURIComponent(args.accountId);
+ const out = await getLocalJson(args.token, `weixin/outbound/pending?account_id=${q}&limit=20`, 8000);
+ const items = Array.isArray(out.items) ? (out.items as Json[]) : [];
+ for (const item of items) {
+ const toUser = String(item.chat_id || "").trim();
+ const text = String(item.text || "").trim();
+ const msgId = String(item.id || "").trim();
+ if (!toUser || !text || !msgId) continue;
+ const contextToken = String(
+ (item.context_token as string) ||
+ args.modules.getContextToken(args.accountId, toUser) ||
+ args.userContextTokens[toUser] ||
+ "",
+ ).trim();
+ if (!contextToken) {
+ log(`db proactive reply missing context_token; keep pending. id=${msgId} to=${toUser}`);
+ continue;
+ }
+ try {
+ await args.modules.sendMessageWeixin({
+ to: toUser,
+ text,
+ opts: {
+ baseUrl: args.cloudBaseUrl,
+ token: args.token,
+ contextToken,
+ },
+ });
+ await postLocalJson(args.token, "weixin/outbound/ack", { id: msgId, ok: true }, 8000);
+ log(`db proactive reply sent: id=${msgId} to=${toUser} textLen=${text.length}`);
+ } catch (err) {
+ try {
+ await postLocalJson(
+ args.token,
+ "weixin/outbound/ack",
+ { id: msgId, ok: false, error: String(err) },
+ 8000,
+ );
+ } catch (_) {
+ // ignore ack failure
+ }
+ log(`db proactive reply failed: id=${msgId} to=${toUser} err=${String(err)}`);
+ }
+ }
+}
+
+async function flushLocalProactiveReplies(args: {
+ modules: OfficialModules;
+ token: string;
+ accountId: string;
+ cloudBaseUrl: string;
+ localCursor: string;
+ userContextTokens: TokenMap;
+}): Promise {
+ let cursor = args.localCursor;
+ for (let i = 0; i < 3; i += 1) {
+ const out = await postLocalJson(
+ args.token,
+ "ilink/bot/getupdates",
+ {
+ channel: "wechat",
+ account_id: args.accountId,
+ get_updates_buf: cursor,
+ longpolling_timeout_ms: 1000,
+ limit: 20,
+ },
+ 8000,
+ );
+ const msgs = Array.isArray(out.msgs) ? (out.msgs as Json[]) : [];
+ const next = String(out.get_updates_buf || cursor || "").trim();
+ const batchCursor = cursor;
+ const nextCursor = next || cursor;
+ if (!msgs.length) {
+ break;
+ }
+ let allSucceeded = true;
+ for (const r of msgs) {
+ const toUser = String(r.chat_id || "").trim();
+ const text = String(r.text || "").trim();
+ if (!toUser || !text) continue;
+ const contextToken = String(
+ (r.context_token as string) ||
+ args.modules.getContextToken(args.accountId, toUser) ||
+ args.userContextTokens[toUser] ||
+ "",
+ ).trim();
+ if (!contextToken) {
+ allSucceeded = false;
+ log(`proactive reply missing context_token; keep cursor. to=${toUser} textLen=${text.length}`);
+ continue;
+ }
+ try {
+ await args.modules.sendMessageWeixin({
+ to: toUser,
+ text,
+ opts: {
+ baseUrl: args.cloudBaseUrl,
+ token: args.token,
+ contextToken,
+ },
+ });
+ log(`proactive reply sent: to=${toUser} textLen=${text.length}`);
+ } catch (err) {
+ log(`proactive reply failed: to=${toUser} err=${String(err)}`);
+ allSucceeded = false;
+ }
+ }
+ cursor = allSucceeded ? nextCursor : batchCursor;
+ }
+ return cursor;
+}
+
async function postNativeReply(token: string, body: Json): Promise {
const url = `${LOCAL_BASE_URL.replace(/\/+$/, "")}/weixin/native/reply`;
const timeoutMs = Number(process.env.OCLAW_WEIXIN_NATIVE_REPLY_TIMEOUT_MS || "100000") || 100000;
@@ -490,6 +638,7 @@ async function main(): Promise {
ensureDir(STATE_DIR);
const state = (readJsonFile(STATE_FILE) || {}) as Json;
let cloudCursor = String(state.cloud_cursor || "").trim();
+ let localCursor = String(state.local_cursor || "").trim();
const userContextTokens: TokenMap =
state.user_context_tokens && typeof state.user_context_tokens === "object"
? (state.user_context_tokens as TokenMap)
@@ -500,6 +649,25 @@ async function main(): Promise {
log(`official runner started account=${accountId} cloud=${cloudBaseUrl} local=${LOCAL_BASE_URL}`);
while (true) {
try {
+ try {
+ await flushWeixinDbOutbound({
+ modules,
+ token,
+ accountId,
+ cloudBaseUrl,
+ userContextTokens,
+ });
+ } catch (err) {
+ log(`db proactive flush error: ${String(err)}`);
+ }
+ localCursor = await flushLocalProactiveReplies({
+ modules,
+ token,
+ accountId,
+ cloudBaseUrl,
+ localCursor,
+ userContextTokens,
+ });
const out = await modules.getUpdates({
baseUrl: cloudBaseUrl,
token,
@@ -530,6 +698,7 @@ async function main(): Promise {
}
writeJsonFile(STATE_FILE, {
cloud_cursor: cloudCursor,
+ local_cursor: localCursor,
user_context_tokens: userContextTokens,
updated_at: new Date().toISOString(),
});
diff --git a/runtime/scheduler/__init__.py b/runtime/scheduler/__init__.py
new file mode 100644
index 00000000..4d21ee85
--- /dev/null
+++ b/runtime/scheduler/__init__.py
@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+__all__ = []
diff --git a/runtime/scheduler/channel_delivery.py b/runtime/scheduler/channel_delivery.py
new file mode 100644
index 00000000..81d7f36b
--- /dev/null
+++ b/runtime/scheduler/channel_delivery.py
@@ -0,0 +1,252 @@
+from __future__ import annotations
+
+import json
+import os
+from typing import Any
+
+from runtime.orchestration.group_ingest import is_nonsend_channel_reply_text, should_send_channel_reply_text
+from runtime.scheduler.session_resolver import parse_delivery_json
+
+
+def _encode_weixin_outbound_source(*, context_token: str) -> str:
+ return json.dumps(
+ {"kind": "scheduled_job", "context_token": str(context_token or "").strip()},
+ ensure_ascii=False,
+ )
+
+
+def _decode_weixin_outbound_source(raw: str) -> dict[str, Any]:
+ text = str(raw or "").strip()
+ if not text:
+ return {}
+ try:
+ data = json.loads(text)
+ return data if isinstance(data, dict) else {}
+ except Exception:
+ return {}
+
+
+def enqueue_weixin_reply(
+ *,
+ channel: str,
+ account_id: str,
+ chat_id: str,
+ text: str,
+ context_token: str = "",
+ store: Any = None,
+ tenant_id: str = "",
+) -> dict[str, Any]:
+ from runtime.scheduler.weixin_delivery import normalize_weixin_channel
+
+ ctx_tok = str(context_token or "").strip()
+ if not ctx_tok:
+ return {
+ "ok": False,
+ "channel": normalize_weixin_channel(channel),
+ "error": "context_token_missing",
+ "hint": "Send any message to the bot on WeChat first, then retry the scheduled job.",
+ }
+ durable_id = ""
+ enqueuer = getattr(store, "enqueue_channel_outbound_message", None)
+ if store is not None and callable(enqueuer):
+ try:
+ durable_id = str(
+ enqueuer(
+ channel=normalize_weixin_channel(channel),
+ chat_id=str(chat_id or "").strip(),
+ text=str(text or ""),
+ tenant_id=str(tenant_id or ""),
+ account_id=str(account_id or "").strip(),
+ source=_encode_weixin_outbound_source(context_token=ctx_tok),
+ )
+ or ""
+ ).strip()
+ except Exception:
+ durable_id = ""
+ try:
+ from interfaces.http.weixin_ilink_api import enqueue_weixin_outbound_reply
+ except Exception as exc:
+ if durable_id:
+ return {
+ "ok": True,
+ "channel": normalize_weixin_channel(channel),
+ "message_id": durable_id,
+ "queued": True,
+ "durable": True,
+ "context_token_present": True,
+ "bridge_error": f"{type(exc).__name__}: {exc}",
+ }
+ return {"ok": False, "channel": channel, "error": f"{type(exc).__name__}: {exc}"}
+ try:
+ bridge_seq = enqueue_weixin_outbound_reply(
+ channel=normalize_weixin_channel(channel),
+ account_id=str(account_id or "").strip(),
+ chat_id=str(chat_id or "").strip(),
+ text=text,
+ context_token=ctx_tok,
+ )
+ return {
+ "ok": True,
+ "channel": normalize_weixin_channel(channel),
+ "message_id": durable_id or bridge_seq,
+ "bridge_seq": bridge_seq,
+ "queued": True,
+ "durable": bool(durable_id),
+ "context_token_present": True,
+ "account_id": str(account_id or "").strip(),
+ "chat_id": str(chat_id or "").strip(),
+ }
+ except Exception as exc:
+ if durable_id:
+ return {
+ "ok": True,
+ "channel": normalize_weixin_channel(channel),
+ "message_id": durable_id,
+ "queued": True,
+ "durable": True,
+ "context_token_present": True,
+ "bridge_error": f"{type(exc).__name__}: {exc}",
+ }
+ return {"ok": False, "channel": channel, "error": f"{type(exc).__name__}: {exc}"}
+
+
+def persist_channel_context_token(
+ store: Any,
+ *,
+ tenant_id: str,
+ channel: str,
+ account_id: str,
+ external_chat_id: str,
+ context_token: str,
+) -> None:
+ from runtime.scheduler.weixin_delivery import normalize_weixin_channel
+
+ setter = getattr(store, "set_channel_context_token", None)
+ if not callable(setter):
+ return
+ tok = str(context_token or "").strip()
+ chat_id = str(external_chat_id or "").strip()
+ if not tok or not chat_id:
+ return
+ tid = str(tenant_id or "")
+ acct = str(account_id or "").strip()
+ channels = []
+ for ch in (channel, "wechat", "weixin"):
+ c = normalize_weixin_channel(str(ch or "")) if str(ch or "").lower() in {"wechat", "weixin"} else str(ch or "").strip().lower()
+ if c and c not in channels:
+ channels.append(c)
+ account_ids = [acct] if acct else [""]
+ if acct:
+ account_ids.append("")
+ for ch in channels:
+ for aid in account_ids:
+ setter(
+ tenant_id=tid,
+ channel=ch,
+ account_id=aid,
+ external_chat_id=chat_id,
+ context_token=tok,
+ )
+
+
+def extract_context_token_from_inbound_metadata(metadata: dict[str, Any] | None) -> str:
+ meta = metadata if isinstance(metadata, dict) else {}
+ raw = meta.get("raw") if isinstance(meta.get("raw"), dict) else {}
+ msg = raw.get("msg") if isinstance(raw.get("msg"), dict) else {}
+ for candidate in (
+ msg.get("context_token"),
+ (raw.get("metadata") or {}).get("context_token") if isinstance(raw.get("metadata"), dict) else None,
+ raw.get("context_token"),
+ meta.get("context_token"),
+ ):
+ tok = str(candidate or "").strip()
+ if tok:
+ return tok
+ return ""
+
+
+def deliver_scheduled_reply(
+ store: Any,
+ *,
+ tenant_id: str,
+ reply_text: str,
+ delivery_json: str,
+ resolved_channel: str = "",
+ resolved_chat_id: str = "",
+ resolved_account_id: str = "",
+ session_id: str = "",
+) -> dict[str, Any]:
+ text = str(reply_text or "").strip()
+ if not text or is_nonsend_channel_reply_text(text):
+ return {"ok": False, "skipped": True, "reason": "empty_or_silent_reply"}
+
+ ch_lower = str(resolved_channel or "").strip().lower()
+ if ch_lower in {"wechat", "weixin"}:
+ from runtime.application.gateway.inbound_service import _user_facing_wechat_reply
+
+ text = _user_facing_wechat_reply(reply=text)
+
+ delivery = parse_delivery_json(delivery_json)
+ results: dict[str, Any] = {}
+
+ wa = delivery.get("whatsapp") if isinstance(delivery.get("whatsapp"), dict) else {}
+ wa_enabled = bool(wa.get("enabled")) and str(wa.get("target_type") or "none") != "none"
+ chat_id = str(wa.get("chat_id") or resolved_chat_id or "").strip()
+ account_id = str(
+ wa.get("account_id") or resolved_account_id or os.getenv("AIA_WHATSAPP_ACCOUNT_ID") or "wa-default"
+ ).strip()
+ if wa_enabled and chat_id and should_send_channel_reply_text(text):
+ msg_id = store.enqueue_channel_outbound_message(
+ channel="whatsapp",
+ chat_id=chat_id,
+ text=text,
+ tenant_id=tenant_id,
+ account_id=account_id,
+ source="scheduled_job",
+ )
+ results["whatsapp"] = {"ok": True, "message_id": msg_id, "chat_id": chat_id}
+
+ wx = delivery.get("weixin") if isinstance(delivery.get("weixin"), dict) else {}
+ wx_enabled = bool(wx.get("enabled", True))
+ if wx_enabled and should_send_channel_reply_text(text):
+ from runtime.scheduler.weixin_delivery import resolve_weixin_delivery_target
+
+ target = resolve_weixin_delivery_target(
+ store,
+ tenant_id=tenant_id,
+ session_id=session_id,
+ delivery=delivery,
+ resolved_channel=resolved_channel,
+ resolved_chat_id=resolved_chat_id,
+ resolved_account_id=resolved_account_id,
+ )
+ wx_chat = str(target.get("chat_id") or "").strip()
+ wx_account = str(target.get("account_id") or "").strip()
+ wx_channel = str(target.get("channel") or "wechat")
+ context_token = str(target.get("context_token") or "").strip()
+ if wx_chat:
+ results["weixin"] = enqueue_weixin_reply(
+ channel=wx_channel,
+ account_id=wx_account,
+ chat_id=wx_chat,
+ text=text,
+ context_token=context_token,
+ store=store,
+ tenant_id=tenant_id,
+ )
+ else:
+ results["weixin"] = {"ok": False, "error": "weixin_chat_missing"}
+
+ if not results:
+ return {"ok": True, "skipped": True, "reason": "no_delivery_targets"}
+
+ ok = all(bool((v or {}).get("ok")) for v in results.values() if isinstance(v, dict))
+ return {"ok": ok, "channels": results}
+
+
+__all__ = [
+ "deliver_scheduled_reply",
+ "enqueue_weixin_reply",
+ "extract_context_token_from_inbound_metadata",
+ "persist_channel_context_token",
+]
diff --git a/runtime/scheduler/cron_service.py b/runtime/scheduler/cron_service.py
new file mode 100644
index 00000000..b7083501
--- /dev/null
+++ b/runtime/scheduler/cron_service.py
@@ -0,0 +1,201 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from runtime.scheduler.expressions import compute_next_run_at, normalize_schedule_kind
+from runtime.scheduler.service import run_scheduled_job_now
+from runtime.scheduler.session_resolver import parse_delivery_json, resolve_weixin_binding
+
+
+class CronService:
+ def __init__(self, *, store: Any) -> None:
+ self.store = store
+
+ def status(self) -> dict[str, Any]:
+ return {"running": True}
+
+ def wake(self, params: dict[str, Any]) -> dict[str, Any]:
+ return {"ok": True, **dict(params or {})}
+
+ def listPage(self, params: dict[str, Any]) -> dict[str, Any]:
+ tenant_id = str((params or {}).get("tenantId") or (params or {}).get("tenant_id") or "default").strip()
+ status = str((params or {}).get("enabled") or (params or {}).get("status") or "").strip() or None
+ if status in {"true", "1"}:
+ status = "active"
+ elif status in {"false", "0"}:
+ status = "paused"
+ limit = int((params or {}).get("limit") or 50)
+ offset = int((params or {}).get("offset") or 0)
+ rows = self.store.scheduled_job_list(
+ tenant_id=tenant_id,
+ status=status,
+ limit=limit,
+ offset=offset,
+ )
+ items = [self._job_to_gateway_item(self.store.scheduled_job_to_dict(r)) for r in rows]
+ return {"items": items, "total": len(items)}
+
+ def add(self, params: dict[str, Any]) -> dict[str, Any]:
+ p = dict(params or {})
+ tenant_id = str(p.get("tenantId") or p.get("tenant_id") or "default").strip()
+ name = str(p.get("name") or p.get("schedule") or "cron job").strip()
+ schedule = str(p.get("schedule") or p.get("schedule_expr") or "").strip()
+ schedule_kind = normalize_schedule_kind(p.get("schedule_kind") or p.get("scheduleKind") or "cron")
+ prompt = str(p.get("prompt") or p.get("prompt_text") or p.get("text") or name).strip()
+ job = self.store.scheduled_job_create(
+ tenant_id=tenant_id,
+ name=name,
+ prompt_text=prompt,
+ schedule_kind=schedule_kind,
+ schedule_expr=schedule,
+ timezone_name=str(p.get("timezone") or "Asia/Shanghai"),
+ description=str(p.get("description") or ""),
+ interaction_mode=str(p.get("interaction_mode") or "expert"),
+ specialist=str(p.get("specialist") or "generalist"),
+ lang=str(p.get("lang") or "zh"),
+ delivery=p.get("delivery") if isinstance(p.get("delivery"), dict) else {},
+ source="gateway",
+ )
+ return self._job_to_gateway_item(self.store.scheduled_job_to_dict(job))
+
+ def update(self, job_id: str, patch: dict[str, Any]) -> dict[str, Any]:
+ p = dict(patch or {})
+ tenant_id = str(p.pop("tenantId", None) or p.pop("tenant_id", None) or "default").strip()
+ mapped: dict[str, Any] = {}
+ for src, dst in (
+ ("name", "name"),
+ ("schedule", "schedule_expr"),
+ ("schedule_kind", "schedule_kind"),
+ ("prompt", "prompt_text"),
+ ("prompt_text", "prompt_text"),
+ ("timezone", "timezone"),
+ ("interaction_mode", "interaction_mode"),
+ ("specialist", "specialist"),
+ ("lang", "lang"),
+ ("delivery", "delivery"),
+ ("enabled", "status"),
+ ):
+ if src in p:
+ mapped[dst] = p[src]
+ if "enabled" in mapped:
+ mapped["status"] = "active" if bool(mapped.pop("enabled")) else "paused"
+ job = self.store.scheduled_job_update(tenant_id=tenant_id, job_id=str(job_id), patch=mapped)
+ if not job:
+ return {"id": job_id, "ok": False}
+ return self._job_to_gateway_item(self.store.scheduled_job_to_dict(job))
+
+ def remove(self, job_id: str) -> dict[str, Any]:
+ rows = self.store.scheduled_job_list(tenant_id="default", limit=500)
+ for row in rows:
+ if str(row.id) == str(job_id):
+ self.store.scheduled_job_delete(tenant_id=row.tenant_id, job_id=str(job_id))
+ return {"removed": True, "id": job_id}
+ self.store.scheduled_job_delete(tenant_id="default", job_id=str(job_id))
+ return {"removed": True, "id": job_id}
+
+ def enqueueRun(self, job_id: str, mode: str = "force") -> dict[str, Any]:
+ rows = self.store.scheduled_job_list(tenant_id="default", limit=500)
+ tenant_id = "default"
+ for row in rows:
+ if str(row.id) == str(job_id):
+ tenant_id = str(row.tenant_id)
+ break
+ out = run_scheduled_job_now(self.store, tenant_id=tenant_id, job_id=str(job_id))
+ return {"ok": bool(out.get("ok")), "ran": bool(out.get("ok")), "jobId": job_id, "mode": mode, **out}
+
+ def listRuns(self, params: dict[str, Any]) -> dict[str, Any]:
+ p = dict(params or {})
+ job_id = str(p.get("jobId") or p.get("id") or "").strip()
+ tenant_id = str(p.get("tenantId") or p.get("tenant_id") or "default").strip()
+ limit = int(p.get("limit") or 50)
+ if not job_id:
+ return {"items": [], "total": 0}
+ rows = self.store.scheduled_job_run_list(job_id=job_id, tenant_id=tenant_id, limit=limit)
+ items = [self.store.scheduled_job_run_to_dict(r) for r in rows]
+ return {"items": items, "total": len(items), "jobId": job_id}
+
+ def _job_to_gateway_item(self, row: dict[str, Any]) -> dict[str, Any]:
+ return {
+ "id": row.get("id"),
+ "name": row.get("name"),
+ "schedule": row.get("schedule_expr"),
+ "schedule_kind": row.get("schedule_kind"),
+ "enabled": str(row.get("status") or "") == "active",
+ "prompt": row.get("prompt_text"),
+ "timezone": row.get("timezone"),
+ "nextRunAt": row.get("next_run_at"),
+ "lastRunAt": row.get("last_run_at"),
+ "specialist": row.get("specialist"),
+ "interaction_mode": row.get("interaction_mode"),
+ "delivery": row.get("delivery"),
+ }
+
+
+def build_default_delivery(*, store: Any, tenant_id: str, whatsapp_chat_id: str = "") -> dict[str, Any]:
+ import os
+
+ delivery: dict[str, Any] = {
+ "whatsapp": {
+ "enabled": bool(str(whatsapp_chat_id or "").strip()),
+ "target_type": "group" if str(whatsapp_chat_id or "").endswith("@g.us") else "direct",
+ "chat_id": str(whatsapp_chat_id or ""),
+ "account_id": str(os.getenv("AIA_WHATSAPP_ACCOUNT_ID") or "wa-default"),
+ },
+ "weixin": {"enabled": True, "fixed": True},
+ }
+ if not delivery["whatsapp"]["enabled"]:
+ delivery["whatsapp"]["target_type"] = "none"
+ binding = resolve_weixin_binding(store, tenant_id=tenant_id)
+ if binding:
+ ext = str(binding.get("external_user_id") or "")
+ delivery["weixin"]["external_user_id"] = ext
+ delivery["weixin"]["external_chat_id"] = str(binding.get("external_chat_id") or ext)
+ delivery["weixin"]["account_id"] = str(binding.get("account_id") or "weixin-default")
+ return delivery
+
+
+def build_delivery_for_session(
+ store: Any,
+ *,
+ tenant_id: str,
+ session_id: str = "",
+ whatsapp_chat_id: str = "",
+) -> dict[str, Any]:
+ """Pick delivery targets from the chat session that created the job (WhatsApp vs WeChat)."""
+ import os
+
+ tid = str(tenant_id or "").strip()
+ sid = str(session_id or "").strip()
+ explicit_wa = str(whatsapp_chat_id or "").strip()
+ lookup = getattr(store, "lookup_channel_session_by_session_id", None)
+ if sid and callable(lookup):
+ ctx = lookup(tenant_id=tid, session_id=sid)
+ if isinstance(ctx, dict):
+ ch = str(ctx.get("channel") or "").strip().lower()
+ chat_id = str(ctx.get("external_chat_id") or "").strip()
+ acct = str(ctx.get("account_id") or "").strip()
+ if ch == "whatsapp" and chat_id:
+ return {
+ "whatsapp": {
+ "enabled": True,
+ "target_type": "group" if chat_id.endswith("@g.us") else "direct",
+ "chat_id": chat_id,
+ "account_id": acct or str(os.getenv("AIA_WHATSAPP_ACCOUNT_ID") or "wa-default"),
+ },
+ "weixin": {"enabled": False, "fixed": False},
+ }
+ if ch in {"weixin", "wechat"}:
+ delivery = build_default_delivery(store=store, tenant_id=tid, whatsapp_chat_id="")
+ wa = delivery.get("whatsapp") if isinstance(delivery.get("whatsapp"), dict) else {}
+ delivery["whatsapp"] = {
+ **wa,
+ "enabled": False,
+ "target_type": "none",
+ "chat_id": "",
+ }
+ return delivery
+ return build_default_delivery(store=store, tenant_id=tid, whatsapp_chat_id=explicit_wa)
+
+
+__all__ = ["CronService", "build_default_delivery", "build_delivery_for_session", "compute_next_run_at"]
diff --git a/runtime/scheduler/expressions.py b/runtime/scheduler/expressions.py
new file mode 100644
index 00000000..5bd81e82
--- /dev/null
+++ b/runtime/scheduler/expressions.py
@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+from typing import Any
+from zoneinfo import ZoneInfo
+
+try:
+ from croniter import croniter
+except ImportError: # pragma: no cover - guarded in requirements
+ croniter = None # type: ignore[assignment,misc]
+
+
+def normalize_schedule_kind(raw: Any) -> str:
+ kind = str(raw or "").strip().lower()
+ if kind in {"cron", "once", "interval"}:
+ return kind
+ return "cron"
+
+
+def _parse_iso_dt(value: str) -> datetime:
+ text = str(value or "").strip()
+ if not text:
+ raise ValueError("empty datetime")
+ if text.endswith("Z"):
+ text = text[:-1] + "+00:00"
+ dt = datetime.fromisoformat(text)
+ if dt.tzinfo is None:
+ dt = dt.replace(tzinfo=timezone.utc)
+ return dt.astimezone(timezone.utc)
+
+
+def compute_next_run_at(
+ *,
+ schedule_kind: str,
+ schedule_expr: str,
+ timezone_name: str = "Asia/Shanghai",
+ from_dt: datetime | None = None,
+) -> str | None:
+ kind = normalize_schedule_kind(schedule_kind)
+ expr = str(schedule_expr or "").strip()
+ if not expr:
+ return None
+ base = from_dt or datetime.now(timezone.utc)
+ if base.tzinfo is None:
+ base = base.replace(tzinfo=timezone.utc)
+ else:
+ base = base.astimezone(timezone.utc)
+
+ if kind == "once":
+ target = _parse_iso_dt(expr)
+ if target <= base:
+ return None
+ return target.isoformat()
+
+ if kind == "interval":
+ try:
+ seconds = max(1, int(expr))
+ except ValueError as exc:
+ raise ValueError(f"invalid interval seconds: {expr}") from exc
+ nxt = base + timedelta(seconds=seconds)
+ return nxt.isoformat()
+
+ if croniter is None:
+ raise RuntimeError("croniter is required for cron schedules")
+ try:
+ tz = ZoneInfo(str(timezone_name or "Asia/Shanghai"))
+ except Exception:
+ tz = ZoneInfo("Asia/Shanghai")
+ local_base = base.astimezone(tz)
+ itr = croniter(expr, local_base)
+ nxt_local = itr.get_next(datetime)
+ if nxt_local.tzinfo is None:
+ nxt_local = nxt_local.replace(tzinfo=tz)
+ return nxt_local.astimezone(timezone.utc).isoformat()
+
+
+__all__ = ["compute_next_run_at", "normalize_schedule_kind"]
diff --git a/runtime/scheduler/service.py b/runtime/scheduler/service.py
new file mode 100644
index 00000000..31fe3c14
--- /dev/null
+++ b/runtime/scheduler/service.py
@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+import json
+import threading
+import time
+import uuid
+from datetime import datetime, timezone
+from typing import Any
+
+from runtime.scheduler.session_resolver import resolve_scheduled_session, resolve_scheduled_viewer_username
+from runtime.scheduler.turn_text import build_scheduled_turn_instruction
+from runtime.worker import ensure_worker_started
+
+_LOCK = threading.Lock()
+_THREAD: threading.Thread | None = None
+_RUNNING = False
+
+
+def _tick_interval_seconds() -> float:
+ import os
+
+ raw = str(os.getenv("AIA_SCHEDULER_TICK_SECONDS") or "30").strip()
+ try:
+ return max(5.0, min(float(raw), 3600.0))
+ except Exception:
+ return 30.0
+
+
+def enqueue_scheduled_job_run(
+ store: Any,
+ *,
+ job: Any,
+ mode: str = "scheduled",
+) -> dict[str, Any]:
+ tenant_id = str(getattr(job, "tenant_id", "") or "")
+ job_id = str(getattr(job, "id") or "")
+ run = store.scheduled_job_run_create(
+ job_id=job_id,
+ tenant_id=tenant_id,
+ scheduled_at=str(getattr(job, "next_run_at", "") or datetime.now(timezone.utc).isoformat()),
+ status="queued",
+ )
+ try:
+ resolved = resolve_scheduled_session(
+ store,
+ job=job,
+ created_by_user_id=str(getattr(job, "created_by_user_id", "") or ""),
+ )
+ except Exception as exc:
+ store.scheduled_job_run_update(
+ run_id=run.id,
+ tenant_id=tenant_id,
+ patch={
+ "status": "failed",
+ "finished_at": datetime.now(timezone.utc).isoformat(),
+ "error": str(exc),
+ },
+ )
+ store.scheduled_job_mark_run(
+ job_id=job_id,
+ tenant_id=tenant_id,
+ last_run_status="failed",
+ pause_after=False,
+ )
+ return {"ok": False, "error": str(exc), "run_id": run.id}
+
+ delivery: dict[str, Any] = {}
+ try:
+ raw = json.loads(str(getattr(job, "delivery_json", "") or "{}"))
+ if isinstance(raw, dict):
+ delivery = raw
+ except Exception:
+ delivery = {}
+
+ trace_id = uuid.uuid4().hex
+ agent_run_id = uuid.uuid4().hex
+ prompt_text = str(getattr(job, "prompt_text", "") or "").strip()
+ lang = str(getattr(job, "lang", "") or "zh")
+ user_text = build_scheduled_turn_instruction(prompt_text=prompt_text, mode=mode, lang=lang)
+ viewer_username = resolve_scheduled_viewer_username(
+ store,
+ tenant_id=tenant_id,
+ user_id=resolved.user_id,
+ channel=resolved.channel,
+ )
+ payload = {
+ "trace_id": trace_id,
+ "run_id": agent_run_id,
+ "session_id": resolved.session_id,
+ "tenant_id": tenant_id,
+ "user_id": resolved.user_id,
+ "viewer_username": viewer_username,
+ "role": "member",
+ "channel": resolved.channel if resolved.channel != "admin_chat" else "admin_chat",
+ "lang": lang,
+ "text": user_text,
+ "prompt_text": prompt_text,
+ "attachments": [],
+ "metadata": {
+ "scheduled_job_id": job_id,
+ "scheduled_run_id": run.id,
+ "interaction_mode": str(getattr(job, "interaction_mode", "") or "expert"),
+ "selected_specialist": str(getattr(job, "specialist", "") or "generalist"),
+ "scheduled_mode": mode,
+ "scheduled_proactive": True,
+ },
+ "interaction_mode": str(getattr(job, "interaction_mode", "") or "expert"),
+ "requested_specialist": str(getattr(job, "specialist", "") or "generalist"),
+ "selected_specialist": str(getattr(job, "specialist", "") or "generalist"),
+ "job_id": job_id,
+ "run_id_scheduled": run.id,
+ "delivery": delivery,
+ "resolved_channel": resolved.channel,
+ "resolved_chat_id": resolved.external_chat_id,
+ "resolved_account_id": resolved.account_id,
+ }
+ worker_id = ensure_worker_started(store=store)
+ task = store.oclaw_task_create(
+ tenant_id=tenant_id,
+ session_id=resolved.session_id,
+ task_type="scheduled_turn",
+ payload=payload,
+ )
+ store.scheduled_job_run_update(
+ run_id=run.id,
+ tenant_id=tenant_id,
+ patch={
+ "status": "running",
+ "started_at": datetime.now(timezone.utc).isoformat(),
+ "session_id": resolved.session_id,
+ "oclaw_task_id": task.id,
+ "run_id": agent_run_id,
+ },
+ )
+ store.scheduled_job_reserve_next_run(job_id=job_id, tenant_id=tenant_id)
+ pause_after = str(getattr(job, "schedule_kind", "") or "") == "once"
+ return {
+ "ok": True,
+ "run_id": run.id,
+ "task_id": task.id,
+ "worker_id": worker_id,
+ "pause_after": pause_after,
+ }
+
+
+def scheduler_tick(store: Any) -> dict[str, Any]:
+ due = store.scheduled_job_list_due(limit=20)
+ triggered = 0
+ errors: list[str] = []
+ for job in due:
+ try:
+ out = enqueue_scheduled_job_run(store, job=job, mode="scheduled")
+ if out.get("ok"):
+ triggered += 1
+ else:
+ errors.append(str(out.get("error") or "enqueue_failed"))
+ except Exception as exc:
+ errors.append(f"{getattr(job, 'id', '')}: {type(exc).__name__}: {exc}")
+ return {"ok": True, "due": len(due), "triggered": triggered, "errors": errors}
+
+
+def run_scheduled_job_now(store: Any, *, tenant_id: str, job_id: str) -> dict[str, Any]:
+ job = store.scheduled_job_get(job_id=job_id, tenant_id=tenant_id)
+ if not job:
+ return {"ok": False, "error": "job_not_found"}
+ if str(job.status or "") != "active":
+ return {"ok": False, "error": "job_not_active"}
+ return enqueue_scheduled_job_run(store, job=job, mode="manual")
+
+
+def _scheduler_loop(*, store: Any) -> None:
+ global _RUNNING
+ interval = _tick_interval_seconds()
+ while _RUNNING:
+ try:
+ scheduler_tick(store)
+ except Exception:
+ pass
+ time.sleep(interval)
+
+
+def ensure_scheduler_started(*, store: Any) -> str:
+ global _THREAD, _RUNNING
+ with _LOCK:
+ if _THREAD and _THREAD.is_alive():
+ return _THREAD.name
+ _RUNNING = True
+ tid = f"oclaw-scheduler-{uuid.uuid4().hex[:8]}"
+ t = threading.Thread(target=_scheduler_loop, kwargs={"store": store}, name=tid, daemon=True)
+ t.start()
+ _THREAD = t
+ return tid
+
+
+__all__ = [
+ "ensure_scheduler_started",
+ "enqueue_scheduled_job_run",
+ "run_scheduled_job_now",
+ "scheduler_tick",
+]
diff --git a/runtime/scheduler/session_resolver.py b/runtime/scheduler/session_resolver.py
new file mode 100644
index 00000000..f327e687
--- /dev/null
+++ b/runtime/scheduler/session_resolver.py
@@ -0,0 +1,262 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from dataclasses import dataclass
+from typing import Any
+
+from runtime.orchestration.group_ingest import session_user_key
+
+
+@dataclass(frozen=True)
+class ResolvedSession:
+ session_id: str
+ tenant_id: str
+ user_id: str
+ channel: str
+ account_id: str
+ external_chat_id: str
+ external_user_id: str
+ is_group: bool
+
+
+def _ensure_administrator_owner(store: Any, *, tenant_id: str) -> dict[str, Any] | None:
+ user = store.get_user_by_username(tenant_id=tenant_id, username="administrator")
+ if not user:
+ try:
+ from svc.config.passwords import load_expected_password
+ except Exception:
+ load_expected_password = None # type: ignore
+ pwd = load_expected_password(store) if callable(load_expected_password) else None
+ if not pwd:
+ return None
+ user = store.create_user_account(
+ tenant_id=tenant_id,
+ username="administrator",
+ password_hash=hashlib.sha256(pwd.encode("utf-8")).hexdigest(),
+ display_name="Administrator",
+ role="owner",
+ is_active=True,
+ )
+ user_id = str((user or {}).get("id") or "")
+ if not user_id:
+ return None
+ return {
+ "tenant_id": tenant_id,
+ "user_id": user_id,
+ "display_name": (user or {}).get("display_name") or "Administrator",
+ "role": str((user or {}).get("role") or "owner"),
+ }
+
+
+def resolve_weixin_binding(store: Any, *, tenant_id: str) -> dict[str, Any] | None:
+ owner = _ensure_administrator_owner(store, tenant_id=tenant_id)
+ if not owner:
+ return None
+ user_id = str(owner.get("user_id") or "")
+ rows = store.list_channel_identities_v2(
+ tenant_id=tenant_id,
+ channel="weixin",
+ user_id=user_id,
+ limit=20,
+ )
+ if not rows:
+ for ch in ("wechat", "weixin"):
+ rows = store.list_channel_identities_v2(
+ tenant_id=tenant_id,
+ channel=ch,
+ user_id=user_id,
+ limit=20,
+ )
+ if rows:
+ break
+ if not rows:
+ return None
+ row = rows[0]
+ account_id = str(row.get("account_id") or "weixin-default").strip() or "weixin-default"
+ external_user_id = str(row.get("external_user_id") or "").strip()
+ if not external_user_id:
+ return None
+ return {
+ "tenant_id": tenant_id,
+ "user_id": user_id,
+ "channel": str(row.get("channel") or "weixin"),
+ "account_id": account_id,
+ "external_user_id": external_user_id,
+ "external_chat_id": external_user_id,
+ "is_group": False,
+ }
+
+
+def parse_delivery_json(raw: str) -> dict[str, Any]:
+ try:
+ data = json.loads(raw or "{}")
+ return data if isinstance(data, dict) else {}
+ except Exception:
+ return {}
+
+
+def resolve_scheduled_viewer_username(
+ store: Any,
+ *,
+ tenant_id: str,
+ user_id: str,
+ channel: str,
+) -> str:
+ """Channel proactive jobs use the administrator model pool (same as gateway inbound)."""
+ ch = str(channel or "").strip().lower()
+ if ch in {"weixin", "wechat", "whatsapp"}:
+ return "administrator"
+ uid = str(user_id or "").strip()
+ if uid:
+ user = store.get_user_by_id(tenant_id=str(tenant_id or ""), user_id=uid)
+ if isinstance(user, dict):
+ uname = str(user.get("username") or "").strip()
+ if uname:
+ return uname
+ return "administrator"
+
+
+def resolve_scheduled_session(
+ store: Any,
+ *,
+ job: Any,
+ created_by_user_id: str = "",
+) -> ResolvedSession:
+ tenant_id = str(getattr(job, "tenant_id", "") or "")
+ delivery = parse_delivery_json(str(getattr(job, "delivery_json", "") or "{}"))
+ source_session_id = str(getattr(job, "source_session_id", "") or "").strip()
+ job_name = str(getattr(job, "name", "") or "Scheduled task")
+
+ if source_session_id:
+ sess = store.get_session_in_tenant(session_id=source_session_id, tenant_id=tenant_id)
+ if sess:
+ owner = store.get_ui_session_owner(session_id=source_session_id) or {}
+ user_id = str(owner.get("user_id") or created_by_user_id or "").strip()
+ if not user_id:
+ admin = _ensure_administrator_owner(store, tenant_id=tenant_id)
+ user_id = str((admin or {}).get("user_id") or "")
+ channel_ctx = None
+ lookup = getattr(store, "lookup_channel_session_by_session_id", None)
+ if callable(lookup):
+ channel_ctx = lookup(tenant_id=tenant_id, session_id=source_session_id)
+ if isinstance(channel_ctx, dict) and str(channel_ctx.get("channel") or "").strip():
+ ch = str(channel_ctx.get("channel") or "").strip().lower()
+ account_id = str(channel_ctx.get("account_id") or "").strip()
+ external_chat_id = str(channel_ctx.get("external_chat_id") or "").strip()
+ external_user_id = str(channel_ctx.get("external_user_id") or "").strip()
+ is_group = ch == "whatsapp" and external_chat_id.endswith("@g.us")
+ return ResolvedSession(
+ session_id=source_session_id,
+ tenant_id=tenant_id,
+ user_id=user_id,
+ channel=ch,
+ account_id=account_id or ("weixin-default" if ch in {"weixin", "wechat"} else ""),
+ external_chat_id=external_chat_id,
+ external_user_id=external_user_id,
+ is_group=is_group,
+ )
+ return ResolvedSession(
+ session_id=source_session_id,
+ tenant_id=tenant_id,
+ user_id=user_id,
+ channel="admin_chat",
+ account_id="",
+ external_chat_id="",
+ external_user_id="",
+ is_group=False,
+ )
+
+ wa = delivery.get("whatsapp") if isinstance(delivery.get("whatsapp"), dict) else {}
+ wx = delivery.get("weixin") if isinstance(delivery.get("weixin"), dict) else {}
+ wa_enabled = bool(wa.get("enabled")) and str(wa.get("target_type") or "none") != "none"
+ wx_enabled = bool(wx.get("enabled", True))
+
+ if wa_enabled and str(wa.get("chat_id") or "").strip():
+ chat_id = str(wa.get("chat_id") or "").strip()
+ account_id = str(wa.get("account_id") or os.getenv("AIA_WHATSAPP_ACCOUNT_ID") or "wa-default").strip()
+ target_type = str(wa.get("target_type") or "direct").strip().lower()
+ is_group = target_type == "group" or chat_id.endswith("@g.us")
+ external_user_id = session_user_key(is_group=is_group, external_user_id=chat_id.split("@", 1)[0])
+ admin = _ensure_administrator_owner(store, tenant_id=tenant_id)
+ user_id = str(created_by_user_id or (admin or {}).get("user_id") or "")
+ session_id = store.get_or_create_channel_session_v2(
+ tenant_id=tenant_id,
+ channel="whatsapp",
+ account_id=account_id,
+ external_chat_id=chat_id,
+ external_user_id=external_user_id,
+ session_title=f"Scheduled · {job_name}",
+ )
+ if user_id:
+ store.ensure_ui_session_owner(session_id=session_id, tenant_id=tenant_id, user_id=user_id)
+ return ResolvedSession(
+ session_id=session_id,
+ tenant_id=tenant_id,
+ user_id=user_id,
+ channel="whatsapp",
+ account_id=account_id,
+ external_chat_id=chat_id,
+ external_user_id=external_user_id,
+ is_group=is_group,
+ )
+
+ if wx_enabled:
+ binding = resolve_weixin_binding(store, tenant_id=tenant_id)
+ if not binding:
+ raise RuntimeError("weixin_binding_missing")
+ channel = str(binding.get("channel") or "weixin")
+ account_id = str(binding.get("account_id") or "weixin-default")
+ external_user_id = str(binding.get("external_user_id") or "")
+ external_chat_id = str(binding.get("external_chat_id") or external_user_id)
+ user_id = str(binding.get("user_id") or created_by_user_id or "")
+ session_id = store.get_or_create_channel_session_v2(
+ tenant_id=tenant_id,
+ channel=channel,
+ account_id=account_id,
+ external_chat_id=external_chat_id,
+ external_user_id=external_user_id,
+ session_title=f"Scheduled · {job_name}",
+ )
+ if user_id:
+ store.ensure_ui_session_owner(session_id=session_id, tenant_id=tenant_id, user_id=user_id)
+ return ResolvedSession(
+ session_id=session_id,
+ tenant_id=tenant_id,
+ user_id=user_id,
+ channel=channel,
+ account_id=account_id,
+ external_chat_id=external_chat_id,
+ external_user_id=external_user_id,
+ is_group=False,
+ )
+
+ admin = _ensure_administrator_owner(store, tenant_id=tenant_id)
+ user_id = str(created_by_user_id or (admin or {}).get("user_id") or "")
+ if not user_id:
+ raise RuntimeError("scheduled_session_owner_missing")
+ sess = store.create_session_for_user(
+ title=f"Scheduled · {job_name}",
+ tenant_id=tenant_id,
+ user_id=user_id,
+ )
+ return ResolvedSession(
+ session_id=str(sess.id),
+ tenant_id=tenant_id,
+ user_id=user_id,
+ channel="admin_chat",
+ account_id="",
+ external_chat_id="",
+ external_user_id="",
+ is_group=False,
+ )
+
+
+__all__ = [
+ "ResolvedSession",
+ "resolve_scheduled_session",
+ "resolve_scheduled_viewer_username",
+ "resolve_weixin_binding",
+ "parse_delivery_json",
+]
diff --git a/runtime/scheduler/turn_text.py b/runtime/scheduler/turn_text.py
new file mode 100644
index 00000000..5d6daac8
--- /dev/null
+++ b/runtime/scheduler/turn_text.py
@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+
+def format_scheduled_user_reminder(prompt_text: str) -> str:
+ body = str(prompt_text or "").strip()
+ if not body:
+ return ""
+ if body.startswith("⏰"):
+ return body
+ return f"⏰ 提醒：{body}"
+
+
+def build_scheduled_turn_instruction(*, prompt_text: str, mode: str, lang: str) -> str:
+ """Internal LLM instruction for proactive scheduled reminders (not user-facing)."""
+ intent = str(prompt_text or "").strip()
+ _ = str(mode or "scheduled").strip()
+ is_en = str(lang or "").lower().startswith("en")
+ if is_en:
+ return (
+ "[Scheduled proactive reminder — internal instruction, not a user message]\n"
+ f"Reminder intent: {intent}\n"
+ "Write a short, friendly proactive reminder TO the user (second person). "
+ "Do not say you received a reminder or that you will remind someone; speak directly to the user."
+ )
+ return (
+ "【定时主动提醒·内部指令，不是用户发言】\n"
+ f"提醒意图：{intent}\n"
+ "请生成一条简短、自然、第二人称的主动提醒消息直接对用户说。"
+ "不要写「收到提醒」「好的我来提醒用户」等元对话；不要假装用户刚说了话。"
+ )
+
+
+def scheduled_turn_system_suffix(*, lang: str) -> str:
+ is_en = str(lang or "").lower().startswith("en")
+ if is_en:
+ return (
+ "\n\n[Scheduled job mode] You are sending a proactive reminder to the user. "
+ "Reply with the reminder text only; do not role-play as the user."
+ )
+ return (
+ "\n\n【定时任务模式】你正在主动向用户发送提醒。"
+ "只输出提醒正文，不要扮演用户，不要写「收到/好的」等对话式应答。"
+ )
+
+
+__all__ = [
+ "build_scheduled_turn_instruction",
+ "format_scheduled_user_reminder",
+ "scheduled_turn_system_suffix",
+]
diff --git a/runtime/scheduler/weixin_delivery.py b/runtime/scheduler/weixin_delivery.py
new file mode 100644
index 00000000..ac11d57d
--- /dev/null
+++ b/runtime/scheduler/weixin_delivery.py
@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from typing import Any
+
+from runtime.scheduler.session_resolver import resolve_weixin_binding
+
+
+def normalize_weixin_channel(channel: str) -> str:
+ ch = str(channel or "wechat").strip().lower()
+ return "wechat" if ch in {"wechat", "weixin"} else ch
+
+
+def resolve_weixin_delivery_target(
+ store: Any,
+ *,
+ tenant_id: str,
+ session_id: str,
+ delivery: dict[str, Any],
+ resolved_channel: str,
+ resolved_chat_id: str,
+ resolved_account_id: str,
+) -> dict[str, Any]:
+ wx = delivery.get("weixin") if isinstance(delivery.get("weixin"), dict) else {}
+ channel = normalize_weixin_channel(
+ str(resolved_channel or wx.get("channel") or "wechat")
+ )
+ chat_id = str(
+ resolved_chat_id or wx.get("external_chat_id") or wx.get("external_user_id") or ""
+ ).strip()
+ account_id = str(
+ resolved_account_id or wx.get("account_id") or ""
+ ).strip()
+
+ sid = str(session_id or "").strip()
+ lookup_sess = getattr(store, "lookup_channel_session_by_session_id", None)
+ if sid and callable(lookup_sess):
+ ctx = lookup_sess(tenant_id=str(tenant_id or ""), session_id=sid)
+ if isinstance(ctx, dict):
+ if not chat_id:
+ chat_id = str(ctx.get("external_chat_id") or ctx.get("external_user_id") or "").strip()
+ if not account_id or account_id == "weixin-default":
+ account_id = str(ctx.get("account_id") or account_id or "").strip()
+ if channel in {"wechat", "weixin"}:
+ channel = normalize_weixin_channel(str(ctx.get("channel") or channel))
+
+ lookup_chat = getattr(store, "lookup_channel_session_by_chat_v2", None)
+ if chat_id and callable(lookup_chat) and (not account_id or account_id == "weixin-default"):
+ ctx = lookup_chat(
+ tenant_id=str(tenant_id or ""),
+ channel=channel,
+ external_chat_id=chat_id,
+ )
+ if isinstance(ctx, dict):
+ acct = str(ctx.get("account_id") or "").strip()
+ if acct:
+ account_id = acct
+
+ if not chat_id:
+ binding = resolve_weixin_binding(store, tenant_id=str(tenant_id or ""))
+ if isinstance(binding, dict):
+ chat_id = str(
+ binding.get("external_chat_id") or binding.get("external_user_id") or ""
+ ).strip()
+ if not account_id or account_id == "weixin-default":
+ account_id = str(binding.get("account_id") or account_id or "").strip()
+ if channel in {"wechat", "weixin"}:
+ channel = normalize_weixin_channel(str(binding.get("channel") or channel))
+
+ context_token = str(wx.get("context_token") or "").strip()
+ getter = getattr(store, "get_channel_context_token_fuzzy", None)
+ if callable(getter) and chat_id and not context_token:
+ context_token = str(
+ getter(
+ tenant_id=str(tenant_id or ""),
+ channel=channel,
+ account_id=account_id,
+ external_chat_id=chat_id,
+ )
+ or ""
+ ).strip()
+
+ return {
+ "channel": channel,
+ "chat_id": chat_id,
+ "account_id": account_id,
+ "context_token": context_token,
+ }
+
+
+__all__ = ["normalize_weixin_channel", "resolve_weixin_delivery_target"]
diff --git a/runtime/scheduler/worker_turn.py b/runtime/scheduler/worker_turn.py
new file mode 100644
index 00000000..779355db
--- /dev/null
+++ b/runtime/scheduler/worker_turn.py
@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from typing import Any
+
+
+from runtime.orchestration.group_ingest import is_nonsend_channel_reply_text
+from runtime.scheduler.turn_text import format_scheduled_user_reminder
+
+
+def resolve_scheduled_outbound_text(*, payload: dict[str, Any], reply_text: str) -> str:
+ text = str(reply_text or "").strip()
+ if text and not is_nonsend_channel_reply_text(text):
+ return text
+ prompt = str(payload.get("prompt_text") or "").strip()
+ if prompt:
+ return format_scheduled_user_reminder(prompt)
+ return ""
+
+
+def _persist_scheduled_assistant_reply(
+ store: Any,
+ *,
+ session_id: str,
+ turn_uuid: str,
+ reply_text: str,
+) -> None:
+ sid = str(session_id or "").strip()
+ body = str(reply_text or "").strip()
+ if not sid or not body:
+ return
+ tu = str(turn_uuid or "").strip()
+ payload = {"scheduled_proactive": True}
+ try:
+ rows = store.get_messages(session_id=sid, limit=80)
+ except Exception:
+ rows = []
+ if tu:
+ for m in rows or []:
+ if str(getattr(m, "role", "") or "").lower() != "assistant":
+ continue
+ if str(getattr(m, "turn_uuid", "") or "").strip() != tu:
+ continue
+ existing = str(getattr(m, "content", "") or "").strip()
+ mid = int(getattr(m, "id", 0) or 0)
+ updater = getattr(store, "update_message_content", None)
+ if existing == body:
+ if mid > 0 and callable(updater):
+ merged = dict(payload)
+ raw_ep = getattr(m, "event_payload", None)
+ if isinstance(raw_ep, dict):
+ merged = {**raw_ep, **merged}
+ elif isinstance(raw_ep, str) and raw_ep.strip():
+ try:
+ parsed = json.loads(raw_ep)
+ if isinstance(parsed, dict):
+ merged = {**parsed, **merged}
+ except Exception:
+ pass
+ updater(
+ session_id=sid,
+ message_id=mid,
+ content=body,
+ event_payload=merged,
+ )
+ return
+ if not existing:
+ if mid > 0 and callable(updater):
+ updater(
+ session_id=sid,
+ message_id=mid,
+ content=body,
+ event_payload=payload,
+ )
+ return
+ break
+ for m in rows or []:
+ if str(getattr(m, "role", "") or "").lower() != "assistant":
+ continue
+ if str(getattr(m, "content", "") or "").strip() == body:
+ return
+ try:
+ store.add_message(
+ session_id=sid,
+ role="assistant",
+ content=body,
+ turn_uuid=tu or None,
+ event_type="assistant_text",
+ event_payload=payload,
+ )
+ except Exception:
+ pass
+
+
+def finalize_scheduled_turn_success(
+ store: Any,
+ *,
+ task: Any,
+ payload: dict[str, Any],
+ base_result: dict[str, Any],
+) -> None:
+ from runtime.scheduler.channel_delivery import deliver_scheduled_reply
+
+ tenant_id = str(payload.get("tenant_id") or "")
+ job_id = str(payload.get("job_id") or "")
+ scheduled_run_id = str(payload.get("run_id_scheduled") or "")
+ reply_text = resolve_scheduled_outbound_text(payload=payload, reply_text=str(base_result.get("reply_text") or ""))
+ delivery = payload.get("delivery") if isinstance(payload.get("delivery"), dict) else {}
+ delivery_json = json.dumps(delivery, ensure_ascii=False)
+
+ job = store.scheduled_job_get(job_id=job_id, tenant_id=tenant_id) if job_id else None
+ if job:
+ delivery_json = str(getattr(job, "delivery_json", "") or delivery_json)
+
+ _persist_scheduled_assistant_reply(
+ store,
+ session_id=str(payload.get("session_id") or ""),
+ turn_uuid=str(base_result.get("turn_uuid") or payload.get("run_id") or ""),
+ reply_text=reply_text,
+ )
+ delivery_status = deliver_scheduled_reply(
+ store,
+ tenant_id=tenant_id,
+ reply_text=reply_text,
+ delivery_json=delivery_json,
+ resolved_channel=str(payload.get("resolved_channel") or ""),
+ resolved_chat_id=str(payload.get("resolved_chat_id") or ""),
+ resolved_account_id=str(payload.get("resolved_account_id") or ""),
+ session_id=str(payload.get("session_id") or ""),
+ )
+ if scheduled_run_id:
+ store.scheduled_job_run_update(
+ run_id=scheduled_run_id,
+ tenant_id=tenant_id,
+ patch={
+ "status": "success" if delivery_status.get("ok") else "failed",
+ "finished_at": datetime.now(timezone.utc).isoformat(),
+ "reply_text": reply_text,
+ "delivery_status": delivery_status,
+ "session_id": str(payload.get("session_id") or ""),
+ },
+ )
+ if job_id and job:
+ pause_after = str(getattr(job, "schedule_kind", "") or "") == "once"
+ store.scheduled_job_mark_run(
+ job_id=job_id,
+ tenant_id=tenant_id,
+ last_run_status="success" if delivery_status.get("ok") else "failed",
+ pause_after=pause_after,
+ )
+
+
+def finalize_scheduled_turn_failure(
+ store: Any,
+ *,
+ payload: dict[str, Any],
+ error: str,
+) -> None:
+ tenant_id = str(payload.get("tenant_id") or "")
+ job_id = str(payload.get("job_id") or "")
+ scheduled_run_id = str(payload.get("run_id_scheduled") or "")
+ if scheduled_run_id:
+ store.scheduled_job_run_update(
+ run_id=scheduled_run_id,
+ tenant_id=tenant_id,
+ patch={
+ "status": "failed",
+ "finished_at": datetime.now(timezone.utc).isoformat(),
+ "error": str(error or "")[:500],
+ },
+ )
+ if job_id:
+ job = store.scheduled_job_get(job_id=job_id, tenant_id=tenant_id)
+ pause_after = bool(job and str(getattr(job, "schedule_kind", "") or "") == "once")
+ store.scheduled_job_mark_run(
+ job_id=job_id,
+ tenant_id=tenant_id,
+ last_run_status="failed",
+ pause_after=pause_after,
+ )
+
+
+__all__ = ["finalize_scheduled_turn_failure", "finalize_scheduled_turn_success"]
diff --git a/runtime/tools/context_inject.py b/runtime/tools/context_inject.py
new file mode 100644
index 00000000..edcc7931
--- /dev/null
+++ b/runtime/tools/context_inject.py
@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from typing import Any
+
+_CONTEXT_SCOPED_TOOL_PREFIXES = ("schedule_", "todo_")
+_CONTEXT_SCOPED_TOOL_NAMES = frozenset(
+ {
+ "kb_add",
+ "kb_search",
+ }
+)
+
+
+def _session_owner(store: Any, session_id: str) -> tuple[str, str]:
+ sid = str(session_id or "").strip()
+ if not sid:
+ return "", ""
+ try:
+ owner = store.get_ui_session_owner(session_id=sid) or {}
+ except Exception:
+ owner = {}
+ if isinstance(owner, dict):
+ tid = str(owner.get("tenant_id") or "").strip()
+ uid = str(owner.get("user_id") or "").strip()
+ if tid and uid:
+ return tid, uid
+ return "", ""
+
+
+def enrich_tool_arguments(
+ *,
+ store: Any,
+ session_id: str,
+ tool_name: str,
+ arguments: dict[str, Any] | None,
+ path_policy_tenant_id: str | None = None,
+ path_policy_user_id: str | None = None,
+) -> dict[str, Any]:
+ """Inject tenant/user/session context for productivity tools (WeChat, WhatsApp, etc.)."""
+ merged = dict(arguments or {})
+ name = str(tool_name or "").strip()
+ if not name:
+ return merged
+ scoped = name in _CONTEXT_SCOPED_TOOL_NAMES or any(
+ name.startswith(p) for p in _CONTEXT_SCOPED_TOOL_PREFIXES
+ )
+ if not scoped:
+ return merged
+
+ tenant_id = str(path_policy_tenant_id or merged.get("tenant_id") or "").strip()
+ user_id = str(path_policy_user_id or merged.get("owner_user_id") or merged.get("user_id") or "").strip()
+ if not tenant_id or not user_id:
+ o_tid, o_uid = _session_owner(store, session_id)
+ tenant_id = tenant_id or o_tid
+ user_id = user_id or o_uid
+
+ if tenant_id:
+ merged["tenant_id"] = tenant_id
+ if user_id:
+ if name in _CONTEXT_SCOPED_TOOL_NAMES:
+ merged["user_id"] = user_id
+ else:
+ merged["owner_user_id"] = user_id
+ sid = str(session_id or merged.get("session_id") or "").strip()
+ if sid:
+ merged["session_id"] = sid
+ return merged
+
+
+__all__ = ["enrich_tool_arguments"]
diff --git a/runtime/tools/experts/productivity/schedule_tools.py b/runtime/tools/experts/productivity/schedule_tools.py
new file mode 100644
index 00000000..b13f420a
--- /dev/null
+++ b/runtime/tools/experts/productivity/schedule_tools.py
@@ -0,0 +1,334 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from runtime.scheduler.cron_service import build_delivery_for_session
+from runtime.scheduler.expressions import normalize_schedule_kind
+from runtime.scheduler.service import run_scheduled_job_now
+from runtime.types import normalize_interaction_mode, normalize_requested_specialist
+from svc.persistence.assistant_store import get_assistant_store
+from runtime.tools.base import ToolSpec
+from runtime.tools.context_inject import enrich_tool_arguments
+
+
+def _require(s: str, name: str) -> str:
+ v = (s or "").strip()
+ if not v:
+ raise ValueError(f"{name} is required")
+ return v
+
+
+def _parse_delivery_arg(raw: Any) -> dict[str, Any] | None:
+ if raw is None:
+ return None
+ if isinstance(raw, dict):
+ return raw
+ if isinstance(raw, str) and raw.strip():
+ try:
+ data = json.loads(raw)
+ return data if isinstance(data, dict) else None
+ except Exception:
+ return None
+ return None
+
+
+def schedule_create_tool() -> ToolSpec:
+ def handler(args: dict[str, Any]) -> dict[str, Any]:
+ try:
+ store = get_assistant_store()
+ args = enrich_tool_arguments(
+ store=store,
+ session_id=str(args.get("session_id") or ""),
+ tool_name="schedule_create",
+ arguments=args,
+ )
+ tenant_id = _require(str(args.get("tenant_id") or ""), "tenant_id")
+ owner_user_id = _require(
+ str(args.get("owner_user_id") or args.get("user_id") or ""),
+ "owner_user_id",
+ )
+ name = _require(str(args.get("name") or ""), "name")
+ prompt_text = _require(str(args.get("prompt_text") or ""), "prompt_text")
+ schedule_kind = normalize_schedule_kind(str(args.get("schedule_kind") or "cron"))
+ schedule_expr = _require(str(args.get("schedule_expr") or ""), "schedule_expr")
+ delivery = _parse_delivery_arg(args.get("delivery"))
+ if delivery is None:
+ delivery = build_delivery_for_session(
+ store,
+ tenant_id=tenant_id,
+ session_id=str(args.get("session_id") or ""),
+ whatsapp_chat_id=str(args.get("whatsapp_chat_id") or ""),
+ )
+ interaction_mode = normalize_interaction_mode(
+ str(args.get("interaction_mode") or "expert")
+ )
+ specialist = normalize_requested_specialist(
+ str(args.get("specialist") or args.get("selected_specialist") or "generalist")
+ )
+ row = store.scheduled_job_create(
+ tenant_id=tenant_id,
+ name=name,
+ prompt_text=prompt_text,
+ schedule_kind=schedule_kind,
+ schedule_expr=schedule_expr,
+ timezone_name=str(args.get("timezone") or "Asia/Shanghai"),
+ description=str(args.get("description") or ""),
+ interaction_mode=interaction_mode,
+ specialist=specialist,
+ lang=str(args.get("lang") or "zh"),
+ delivery=delivery,
+ source_session_id=str(args.get("session_id") or "").strip() or None,
+ created_by_user_id=owner_user_id,
+ source="chat",
+ )
+ return {"ok": True, "job": store.scheduled_job_to_dict(row)}
+ except Exception as e:
+ return {"ok": False, "error": f"{type(e).__name__}: {e}"}
+
+ return ToolSpec(
+ name="schedule_create",
+ description="Create a scheduled job (cron, once, or interval). Delivery follows the current chat channel (WhatsApp vs WeChat) unless delivery is set explicitly.",
+ parameters={
+ "type": "object",
+ "properties": {
+ "tenant_id": {"type": "string", "description": "Auto-filled from session; do not guess."},
+ "owner_user_id": {"type": "string", "description": "Auto-filled from session."},
+ "session_id": {"type": "string", "description": "Auto-filled from session."},
+ "name": {"type": "string"},
+ "prompt_text": {"type": "string"},
+ "schedule_kind": {"type": "string", "enum": ["cron", "once", "interval"]},
+ "schedule_expr": {"type": "string"},
+ "timezone": {"type": "string", "default": "Asia/Shanghai"},
+ "interaction_mode": {"type": "string"},
+ "specialist": {"type": "string"},
+ "selected_specialist": {"type": "string"},
+ "lang": {"type": "string"},
+ "whatsapp_chat_id": {"type": "string"},
+ "delivery": {"type": "object"},
+ "description": {"type": "string"},
+ },
+ "required": ["name", "prompt_text", "schedule_kind", "schedule_expr"],
+ "additionalProperties": False,
+ },
+ handler=handler,
+ tags=frozenset({"productivity", "write", "schedule"}),
+ )
+
+
+def schedule_list_tool() -> ToolSpec:
+ def handler(args: dict[str, Any]) -> dict[str, Any]:
+ try:
+ store = get_assistant_store()
+ args = enrich_tool_arguments(
+ store=store,
+ session_id=str(args.get("session_id") or ""),
+ tool_name="schedule_list",
+ arguments=args,
+ )
+ tenant_id = _require(str(args.get("tenant_id") or ""), "tenant_id")
+ status = str(args.get("status") or "").strip() or None
+ limit = int(args.get("limit") or 50)
+ rows = store.scheduled_job_list(tenant_id=tenant_id, status=status, limit=limit)
+ return {"ok": True, "items": [store.scheduled_job_to_dict(r) for r in rows]}
+ except Exception as e:
+ return {"ok": False, "error": f"{type(e).__name__}: {e}"}
+
+ return ToolSpec(
+ name="schedule_list",
+ description="List scheduled jobs for a tenant.",
+ parameters={
+ "type": "object",
+ "properties": {
+ "tenant_id": {"type": "string"},
+ "status": {"type": "string"},
+ "limit": {"type": "integer", "default": 50},
+ },
+ "required": [],
+ "additionalProperties": False,
+ },
+ handler=handler,
+ tags=frozenset({"productivity", "schedule"}),
+ )
+
+
+def _scoped_args(store: Any, tool_name: str, args: dict[str, Any]) -> dict[str, Any]:
+ return enrich_tool_arguments(
+ store=store,
+ session_id=str(args.get("session_id") or ""),
+ tool_name=tool_name,
+ arguments=args,
+ )
+
+
+def schedule_update_tool() -> ToolSpec:
+ def handler(args: dict[str, Any]) -> dict[str, Any]:
+ try:
+ store = get_assistant_store()
+ args = _scoped_args(store, "schedule_update", args)
+ tenant_id = _require(str(args.get("tenant_id") or ""), "tenant_id")
+ job_id = _require(str(args.get("job_id") or ""), "job_id")
+ patch: dict[str, Any] = {}
+ for key in (
+ "name",
+ "description",
+ "prompt_text",
+ "schedule_kind",
+ "schedule_expr",
+ "timezone",
+ "interaction_mode",
+ "specialist",
+ "lang",
+ ):
+ if key in args and args.get(key) is not None:
+ patch[key] = args.get(key)
+ delivery = _parse_delivery_arg(args.get("delivery"))
+ if delivery is not None:
+ patch["delivery"] = delivery
+ row = store.scheduled_job_update(tenant_id=tenant_id, job_id=job_id, patch=patch)
+ if not row:
+ return {"ok": False, "error": "job_not_found"}
+ return {"ok": True, "job": store.scheduled_job_to_dict(row)}
+ except Exception as e:
+ return {"ok": False, "error": f"{type(e).__name__}: {e}"}
+
+ return ToolSpec(
+ name="schedule_update",
+ description="Update a scheduled job.",
+ parameters={
+ "type": "object",
+ "properties": {
+ "tenant_id": {"type": "string"},
+ "job_id": {"type": "string"},
+ "name": {"type": "string"},
+ "prompt_text": {"type": "string"},
+ "schedule_kind": {"type": "string"},
+ "schedule_expr": {"type": "string"},
+ "timezone": {"type": "string"},
+ "interaction_mode": {"type": "string"},
+ "specialist": {"type": "string"},
+ "lang": {"type": "string"},
+ "delivery": {"type": "object"},
+ "description": {"type": "string"},
+ },
+ "required": ["job_id"],
+ "additionalProperties": False,
+ },
+ handler=handler,
+ tags=frozenset({"productivity", "write", "schedule"}),
+ )
+
+
+def schedule_pause_tool() -> ToolSpec:
+ def handler(args: dict[str, Any]) -> dict[str, Any]:
+ try:
+ store = get_assistant_store()
+ args = _scoped_args(store, "schedule_pause", args)
+ tenant_id = _require(str(args.get("tenant_id") or ""), "tenant_id")
+ job_id = _require(str(args.get("job_id") or ""), "job_id")
+ ok = store.scheduled_job_set_status(tenant_id=tenant_id, job_id=job_id, status="paused")
+ return {"ok": bool(ok), "job_id": job_id, "status": "paused"}
+ except Exception as e:
+ return {"ok": False, "error": f"{type(e).__name__}: {e}"}
+
+ return ToolSpec(
+ name="schedule_pause",
+ description="Pause a scheduled job.",
+ parameters={
+ "type": "object",
+ "properties": {"tenant_id": {"type": "string"}, "job_id": {"type": "string"}},
+ "required": ["job_id"],
+ "additionalProperties": False,
+ },
+ handler=handler,
+ tags=frozenset({"productivity", "write", "schedule"}),
+ )
+
+
+def schedule_resume_tool() -> ToolSpec:
+ def handler(args: dict[str, Any]) -> dict[str, Any]:
+ try:
+ store = get_assistant_store()
+ args = _scoped_args(store, "schedule_resume", args)
+ tenant_id = _require(str(args.get("tenant_id") or ""), "tenant_id")
+ job_id = _require(str(args.get("job_id") or ""), "job_id")
+ ok = store.scheduled_job_set_status(tenant_id=tenant_id, job_id=job_id, status="active")
+ return {"ok": bool(ok), "job_id": job_id, "status": "active"}
+ except Exception as e:
+ return {"ok": False, "error": f"{type(e).__name__}: {e}"}
+
+ return ToolSpec(
+ name="schedule_resume",
+ description="Resume a paused scheduled job.",
+ parameters={
+ "type": "object",
+ "properties": {"tenant_id": {"type": "string"}, "job_id": {"type": "string"}},
+ "required": ["job_id"],
+ "additionalProperties": False,
+ },
+ handler=handler,
+ tags=frozenset({"productivity", "write", "schedule"}),
+ )
+
+
+def schedule_delete_tool() -> ToolSpec:
+ def handler(args: dict[str, Any]) -> dict[str, Any]:
+ try:
+ store = get_assistant_store()
+ args = _scoped_args(store, "schedule_delete", args)
+ tenant_id = _require(str(args.get("tenant_id") or ""), "tenant_id")
+ job_id = _require(str(args.get("job_id") or ""), "job_id")
+ ok = store.scheduled_job_delete(tenant_id=tenant_id, job_id=job_id)
+ return {"ok": bool(ok), "job_id": job_id}
+ except Exception as e:
+ return {"ok": False, "error": f"{type(e).__name__}: {e}"}
+
+ return ToolSpec(
+ name="schedule_delete",
+ description="Delete (soft) a scheduled job.",
+ parameters={
+ "type": "object",
+ "properties": {"tenant_id": {"type": "string"}, "job_id": {"type": "string"}},
+ "required": ["job_id"],
+ "additionalProperties": False,
+ },
+ handler=handler,
+ tags=frozenset({"productivity", "write", "schedule"}),
+ )
+
+
+def schedule_run_now_tool() -> ToolSpec:
+ def handler(args: dict[str, Any]) -> dict[str, Any]:
+ try:
+ store = get_assistant_store()
+ args = _scoped_args(store, "schedule_run_now", args)
+ tenant_id = _require(str(args.get("tenant_id") or ""), "tenant_id")
+ job_id = _require(str(args.get("job_id") or ""), "job_id")
+ out = run_scheduled_job_now(store, tenant_id=tenant_id, job_id=job_id)
+ return out
+ except Exception as e:
+ return {"ok": False, "error": f"{type(e).__name__}: {e}"}
+
+ return ToolSpec(
+ name="schedule_run_now",
+ description="Trigger a scheduled job immediately.",
+ parameters={
+ "type": "object",
+ "properties": {"tenant_id": {"type": "string"}, "job_id": {"type": "string"}},
+ "required": ["job_id"],
+ "additionalProperties": False,
+ },
+ handler=handler,
+ tags=frozenset({"productivity", "write", "schedule"}),
+ )
+
+
+__all__ = [
+ "schedule_create_tool",
+ "schedule_list_tool",
+ "schedule_update_tool",
+ "schedule_pause_tool",
+ "schedule_resume_tool",
+ "schedule_delete_tool",
+ "schedule_run_now_tool",
+]
diff --git a/runtime/tools/tool_validation.py b/runtime/tools/tool_validation.py
index 338afeb4..be258ae9 100644
--- a/runtime/tools/tool_validation.py
+++ b/runtime/tools/tool_validation.py
@@ -10,6 +10,17 @@ except Exception: # pragma: no cover
validators = None
+def filter_arguments_to_schema(parameters: dict[str, Any], arguments: dict[str, Any]) -> dict[str, Any]:
+ """Drop keys not declared in tool schema when additionalProperties is false."""
+ if not isinstance(arguments, dict):
+ return {}
+ schema = parameters or {}
+ props = schema.get("properties") if isinstance(schema.get("properties"), dict) else {}
+ if schema.get("additionalProperties") is False and props:
+ return {k: v for k, v in arguments.items() if k in props}
+ return dict(arguments)
+
+
def validate_tool_arguments(parameters: dict[str, Any], arguments: dict[str, Any]) -> tuple[bool, str | None]:
"""校验模型给出的 arguments 是否符合工具的 JSON Schema（OpenAI function parameters）。"""
if not isinstance(arguments, dict):
@@ -33,5 +44,5 @@ def validate_tool_arguments(parameters: dict[str, Any], arguments: dict[str, Any
return True, None
-__all__ = ["validate_tool_arguments"]
+__all__ = ["filter_arguments_to_schema", "validate_tool_arguments"]
diff --git a/runtime/worker.py b/runtime/worker.py
index 9614cfae..5771e211 100644
--- a/runtime/worker.py
+++ b/runtime/worker.py
@@ -238,6 +238,7 @@ def _worker_loop(*, store: Any, worker_id: str, poll_interval_s: float) -> None:
tenant_id = str(payload.get("tenant_id") or "")
user_id = str(payload.get("user_id") or "")
viewer_username = str(payload.get("viewer_username") or "")
+ is_scheduled_turn = str(task.task_type or "") == "scheduled_turn"
model_profile_id = str(payload.get("model_profile_id") or "") or None
interaction_mode = normalize_interaction_mode(
str(payload.get("interaction_mode") or metadata.get("interaction_mode") or "")
@@ -284,6 +285,10 @@ def _worker_loop(*, store: Any, worker_id: str, poll_interval_s: float) -> None:
system_prompt = ""
if not system_prompt:
system_prompt = str(getattr(executor, "system_prompt", "") or "")
+ if is_scheduled_turn:
+ from runtime.scheduler.turn_text import scheduled_turn_system_suffix
+
+ system_prompt = str(system_prompt or "") + scheduled_turn_system_suffix(lang=lang)
max_messages = int(store.get_setting("AIA_TURN_MAX_CONTEXT_MESSAGES") or 80)
max_tool_rounds = int(store.get_setting("AIA_TURN_MAX_TOOL_ROUNDS") or 100)
@@ -299,18 +304,19 @@ def _worker_loop(*, store: Any, worker_id: str, poll_interval_s: float) -> None:
attachments=list(attachments or []),
metadata=dict(metadata or {}),
)
- _maybe_rename_from_first_user_message(
- store=store,
- session_id=session_id,
- user_text=user_text,
- attachments=list(attachments or []),
- )
- _maybe_generate_title_on_third_round(store=store, msg=msg, model=getattr(executor, "model", None))
+ if not is_scheduled_turn:
+ _maybe_rename_from_first_user_message(
+ store=store,
+ session_id=session_id,
+ user_text=user_text,
+ attachments=list(attachments or []),
+ )
+ _maybe_generate_title_on_third_round(store=store, msg=msg, model=getattr(executor, "model", None))
run_out = run_agent_core(
store=store,
data=AgentCoreRunInput(
msg=msg,
- persisted_user_text=str(user_text or ""),
+ persisted_user_text="" if is_scheduled_turn else str(user_text or ""),
lang=lang,
system_prompt=system_prompt,
model=executor.model,
@@ -327,10 +333,12 @@ def _worker_loop(*, store: Any, worker_id: str, poll_interval_s: float) -> None:
oclaw_worker_id=worker_id,
skill_binding_role=skill_binding_role,
wire_policy_role=wire_policy_role,
+ persist_user_message=not is_scheduled_turn,
),
)
base_result = {
"run_id": str(run_out.run_id or ""),
+ "turn_uuid": str(run_out.outcome.turn_uuid or ""),
"reply_text": run_out.outcome.final_text,
"tool_trace_count": len(run_out.outcome.tool_traces),
"relay_pointer_count": int(payload.get("relay_pointer_count") or 0),
@@ -344,6 +352,15 @@ def _worker_loop(*, store: Any, worker_id: str, poll_interval_s: float) -> None:
relay_envelope=relay_share_envelope,
)
)
+ if str(task.task_type or "") == "scheduled_turn":
+ from runtime.scheduler.worker_turn import finalize_scheduled_turn_success
+
+ finalize_scheduled_turn_success(
+ store=store,
+ task=task,
+ payload=payload,
+ base_result=base_result,
+ )
store.oclaw_task_finish(task_id=task.id, result=base_result)
if trace_id:
trace_payload = {
@@ -369,6 +386,10 @@ def _worker_loop(*, store: Any, worker_id: str, poll_interval_s: float) -> None:
payload=trace_payload,
)
except Exception as exc:
+ if str(getattr(task, "task_type", "") or "") == "scheduled_turn":
+ from runtime.scheduler.worker_turn import finalize_scheduled_turn_failure
+
+ finalize_scheduled_turn_failure(store=store, payload=payload, error=str(exc))
store.oclaw_task_fail(task_id=task.id, error=str(exc), result={"ok": False})
try:
if trace_id:
diff --git a/svc/persistence/assistant_store_protocol.py b/svc/persistence/assistant_store_protocol.py
index 854ddc5a..1dbadc03 100644
--- a/svc/persistence/assistant_store_protocol.py
+++ b/svc/persistence/assistant_store_protocol.py
@@ -170,6 +170,20 @@ class AssistantStoreProtocol(Protocol):
def todo_create(self, *, tenant_id: 'str', owner_user_id: 'str', title: 'str', due_at: 'str | None' = None, assignee_user_id: 'str | None' = None) -> 'dict[str, Any]': ...
def todo_list(self, *, tenant_id: 'str', assignee_user_id: 'str | None' = None, status: 'str | None' = 'open', limit: 'int' = 50) -> 'list[dict[str, Any]]': ...
def todo_set_status(self, *, tenant_id: 'str', todo_id: 'str', status: 'str') -> 'bool': ...
+ def scheduled_job_create(self, *, tenant_id: 'str', name: 'str', prompt_text: 'str', schedule_kind: 'str', schedule_expr: 'str', timezone_name: 'str' = 'Asia/Shanghai', description: 'str' = '', interaction_mode: 'str' = 'expert', specialist: 'str' = 'generalist', lang: 'str' = 'zh', delivery: 'dict[str, Any] | None' = None, source_session_id: 'str | None' = None, created_by_user_id: 'str' = '', source: 'str' = 'admin', status: 'str' = 'active') -> 'Any': ...
+ def scheduled_job_get(self, *, job_id: 'str', tenant_id: 'str | None' = None) -> 'Any | None': ...
+ def scheduled_job_list(self, *, tenant_id: 'str', status: 'str | None' = None, limit: 'int' = 100, offset: 'int' = 0) -> 'list[Any]': ...
+ def scheduled_job_update(self, *, tenant_id: 'str', job_id: 'str', patch: 'dict[str, Any]') -> 'Any | None': ...
+ def scheduled_job_set_status(self, *, tenant_id: 'str', job_id: 'str', status: 'str') -> 'bool': ...
+ def scheduled_job_delete(self, *, tenant_id: 'str', job_id: 'str') -> 'bool': ...
+ def scheduled_job_list_due(self, *, limit: 'int' = 20, now_iso: 'str | None' = None) -> 'list[Any]': ...
+ def scheduled_job_mark_run(self, *, job_id: 'str', tenant_id: 'str', last_run_status: 'str', pause_after: 'bool' = False) -> 'None': ...
+ def scheduled_job_run_create(self, *, job_id: 'str', tenant_id: 'str', scheduled_at: 'str | None' = None, status: 'str' = 'queued') -> 'Any': ...
+ def scheduled_job_run_get(self, *, run_id: 'str', tenant_id: 'str | None' = None) -> 'Any | None': ...
+ def scheduled_job_run_list(self, *, job_id: 'str', tenant_id: 'str', limit: 'int' = 50, offset: 'int' = 0) -> 'list[Any]': ...
+ def scheduled_job_run_update(self, *, run_id: 'str', tenant_id: 'str', patch: 'dict[str, Any]') -> 'Any | None': ...
+ def scheduled_job_to_dict(self, job: 'Any') -> 'dict[str, Any]': ...
+ def scheduled_job_run_to_dict(self, run: 'Any') -> 'dict[str, Any]': ...
def touch_auth_session(self, *, session_token_hash: 'str') -> 'None': ...
def trim_messages(self, session_id: 'str', keep_last: 'int') -> 'None': ...
def update_llm_profile(self, profile_id: 'str', name: 'str', mode: 'str', model: 'str | None', base_url: 'str | None', *, thinking_mode_enabled: 'bool | None' = None, reasoning_effort: 'str | None' = None) -> 'None': ...
diff --git a/svc/persistence/scheduled_job_store.py b/svc/persistence/scheduled_job_store.py
new file mode 100644
index 00000000..3c36a2be
--- /dev/null
+++ b/svc/persistence/scheduled_job_store.py
@@ -0,0 +1,634 @@
+from __future__ import annotations
+
+import json
+import uuid
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Any
+
+from runtime.scheduler.expressions import compute_next_run_at, normalize_schedule_kind
+
+SCHEDULED_JOB_DDL = """
+CREATE TABLE IF NOT EXISTS scheduled_job (
+ id TEXT PRIMARY KEY,
+ tenant_id TEXT NOT NULL,
+ name TEXT NOT NULL,
+ description TEXT NOT NULL DEFAULT '',
+ status TEXT NOT NULL DEFAULT 'active',
+ schedule_kind TEXT NOT NULL,
+ schedule_expr TEXT NOT NULL,
+ timezone TEXT NOT NULL DEFAULT 'Asia/Shanghai',
+ prompt_text TEXT NOT NULL,
+ interaction_mode TEXT NOT NULL DEFAULT 'expert',
+ specialist TEXT NOT NULL DEFAULT 'generalist',
+ lang TEXT NOT NULL DEFAULT 'zh',
+ delivery_json TEXT NOT NULL DEFAULT '{}',
+ source_session_id TEXT,
+ created_by_user_id TEXT NOT NULL DEFAULT '',
+ source TEXT NOT NULL DEFAULT 'admin',
+ next_run_at TEXT,
+ last_run_at TEXT,
+ last_run_status TEXT NOT NULL DEFAULT '',
+ created_at TEXT NOT NULL,
+ updated_at TEXT NOT NULL
+);
+"""
+
+SCHEDULED_JOB_INDEX_DDL = """
+CREATE INDEX IF NOT EXISTS idx_scheduled_job_due
+ON scheduled_job(status, next_run_at);
+"""
+
+SCHEDULED_JOB_RUN_DDL = """
+CREATE TABLE IF NOT EXISTS scheduled_job_run (
+ id TEXT PRIMARY KEY,
+ job_id TEXT NOT NULL,
+ tenant_id TEXT NOT NULL,
+ status TEXT NOT NULL,
+ scheduled_at TEXT NOT NULL,
+ started_at TEXT,
+ finished_at TEXT,
+ session_id TEXT,
+ oclaw_task_id TEXT,
+ run_id TEXT,
+ reply_text TEXT NOT NULL DEFAULT '',
+ delivery_status_json TEXT NOT NULL DEFAULT '{}',
+ error TEXT NOT NULL DEFAULT '',
+ created_at TEXT NOT NULL,
+ FOREIGN KEY(job_id) REFERENCES scheduled_job(id) ON DELETE CASCADE
+);
+"""
+
+SCHEDULED_JOB_RUN_INDEX_DDL = """
+CREATE INDEX IF NOT EXISTS idx_scheduled_job_run_job
+ON scheduled_job_run(job_id, created_at DESC);
+"""
+
+
+def utc_now_iso() -> str:
+ return datetime.now(timezone.utc).isoformat()
+
+
+@dataclass(frozen=True)
+class ScheduledJob:
+ id: str
+ tenant_id: str
+ name: str
+ description: str
+ status: str
+ schedule_kind: str
+ schedule_expr: str
+ timezone: str
+ prompt_text: str
+ interaction_mode: str
+ specialist: str
+ lang: str
+ delivery_json: str
+ source_session_id: str | None
+ created_by_user_id: str
+ source: str
+ next_run_at: str | None
+ last_run_at: str | None
+ last_run_status: str
+ created_at: str
+ updated_at: str
+
+
+@dataclass(frozen=True)
+class ScheduledJobRun:
+ id: str
+ job_id: str
+ tenant_id: str
+ status: str
+ scheduled_at: str
+ started_at: str | None
+ finished_at: str | None
+ session_id: str | None
+ oclaw_task_id: str | None
+ run_id: str | None
+ reply_text: str
+ delivery_status_json: str
+ error: str
+ created_at: str
+
+
+def _row_to_job(row: Any) -> ScheduledJob:
+ return ScheduledJob(
+ id=str(row["id"] or ""),
+ tenant_id=str(row["tenant_id"] or ""),
+ name=str(row["name"] or ""),
+ description=str(row["description"] or ""),
+ status=str(row["status"] or ""),
+ schedule_kind=str(row["schedule_kind"] or ""),
+ schedule_expr=str(row["schedule_expr"] or ""),
+ timezone=str(row["timezone"] or "Asia/Shanghai"),
+ prompt_text=str(row["prompt_text"] or ""),
+ interaction_mode=str(row["interaction_mode"] or "expert"),
+ specialist=str(row["specialist"] or "generalist"),
+ lang=str(row["lang"] or "zh"),
+ delivery_json=str(row["delivery_json"] or "{}"),
+ source_session_id=str(row["source_session_id"] or "") or None,
+ created_by_user_id=str(row["created_by_user_id"] or ""),
+ source=str(row["source"] or ""),
+ next_run_at=str(row["next_run_at"] or "") or None,
+ last_run_at=str(row["last_run_at"] or "") or None,
+ last_run_status=str(row["last_run_status"] or ""),
+ created_at=str(row["created_at"] or ""),
+ updated_at=str(row["updated_at"] or ""),
+ )
+
+
+def _row_to_run(row: Any) -> ScheduledJobRun:
+ return ScheduledJobRun(
+ id=str(row["id"] or ""),
+ job_id=str(row["job_id"] or ""),
+ tenant_id=str(row["tenant_id"] or ""),
+ status=str(row["status"] or ""),
+ scheduled_at=str(row["scheduled_at"] or ""),
+ started_at=str(row["started_at"] or "") or None,
+ finished_at=str(row["finished_at"] or "") or None,
+ session_id=str(row["session_id"] or "") or None,
+ oclaw_task_id=str(row["oclaw_task_id"] or "") or None,
+ run_id=str(row["run_id"] or "") or None,
+ reply_text=str(row["reply_text"] or ""),
+ delivery_status_json=str(row["delivery_status_json"] or "{}"),
+ error=str(row["error"] or ""),
+ created_at=str(row["created_at"] or ""),
+ )
+
+
+_JOB_SELECT = """
+SELECT id, tenant_id, name, description, status, schedule_kind, schedule_expr, timezone,
+ prompt_text, interaction_mode, specialist, lang, delivery_json, source_session_id,
+ created_by_user_id, source, next_run_at, last_run_at, last_run_status, created_at, updated_at
+FROM scheduled_job
+"""
+
+
+class ScheduledJobStoreMixin:
+ def ensure_scheduled_job_tables(self, conn: Any) -> None:
+ conn.execute(SCHEDULED_JOB_DDL)
+ conn.execute(SCHEDULED_JOB_INDEX_DDL)
+ conn.execute(SCHEDULED_JOB_RUN_DDL)
+ conn.execute(SCHEDULED_JOB_RUN_INDEX_DDL)
+
+ def scheduled_job_create(
+ self,
+ *,
+ tenant_id: str,
+ name: str,
+ prompt_text: str,
+ schedule_kind: str,
+ schedule_expr: str,
+ timezone_name: str = "Asia/Shanghai",
+ description: str = "",
+ interaction_mode: str = "expert",
+ specialist: str = "generalist",
+ lang: str = "zh",
+ delivery: dict[str, Any] | None = None,
+ source_session_id: str | None = None,
+ created_by_user_id: str = "",
+ source: str = "admin",
+ status: str = "active",
+ ) -> ScheduledJob:
+ jid = str(uuid.uuid4())
+ ts = utc_now_iso()
+ kind = normalize_schedule_kind(schedule_kind)
+ tz = str(timezone_name or "Asia/Shanghai").strip() or "Asia/Shanghai"
+ next_run = compute_next_run_at(
+ schedule_kind=kind,
+ schedule_expr=str(schedule_expr or "").strip(),
+ timezone_name=tz,
+ from_dt=None,
+ )
+ delivery_json = json.dumps(delivery or {}, ensure_ascii=False)
+ with self._connect() as conn: # type: ignore[attr-defined]
+ conn.execute(
+ """
+ INSERT INTO scheduled_job
+ (id, tenant_id, name, description, status, schedule_kind, schedule_expr, timezone,
+ prompt_text, interaction_mode, specialist, lang, delivery_json, source_session_id,
+ created_by_user_id, source, next_run_at, last_run_at, last_run_status, created_at, updated_at)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, '', ?, ?)
+ """,
+ (
+ jid,
+ str(tenant_id),
+ str(name or "").strip() or "Scheduled task",
+ str(description or ""),
+ str(status or "active"),
+ kind,
+ str(schedule_expr or "").strip(),
+ tz,
+ str(prompt_text or "").strip(),
+ str(interaction_mode or "expert"),
+ str(specialist or "generalist"),
+ str(lang or "zh"),
+ delivery_json,
+ str(source_session_id) if source_session_id else None,
+ str(created_by_user_id or ""),
+ str(source or "admin"),
+ next_run,
+ ts,
+ ts,
+ ),
+ )
+ got = self.scheduled_job_get(job_id=jid, tenant_id=tenant_id)
+ if not got:
+ raise RuntimeError("failed to create scheduled job")
+ return got
+
+ def scheduled_job_get(self, *, job_id: str, tenant_id: str | None = None) -> ScheduledJob | None:
+ with self._connect() as conn: # type: ignore[attr-defined]
+ if tenant_id:
+ row = conn.execute(
+ f"{_JOB_SELECT} WHERE id = ? AND tenant_id = ?",
+ (str(job_id), str(tenant_id)),
+ ).fetchone()
+ else:
+ row = conn.execute(f"{_JOB_SELECT} WHERE id = ?", (str(job_id),)).fetchone()
+ if not row:
+ return None
+ return _row_to_job(row)
+
+ def scheduled_job_list(
+ self,
+ *,
+ tenant_id: str,
+ status: str | None = None,
+ limit: int = 100,
+ offset: int = 0,
+ ) -> list[ScheduledJob]:
+ lim = max(1, min(int(limit), 500))
+ off = max(0, int(offset))
+ where = ["tenant_id = ?", "status != 'deleted'"]
+ params: list[Any] = [str(tenant_id)]
+ if status:
+ where.append("status = ?")
+ params.append(str(status))
+ wsql = " AND ".join(where)
+ with self._connect() as conn: # type: ignore[attr-defined]
+ rows = conn.execute(
+ f"{_JOB_SELECT} WHERE {wsql} ORDER BY updated_at DESC LIMIT ? OFFSET ?",
+ (*params, lim, off),
+ ).fetchall()
+ return [_row_to_job(r) for r in rows]
+
+ def scheduled_job_update(
+ self,
+ *,
+ tenant_id: str,
+ job_id: str,
+ patch: dict[str, Any],
+ ) -> ScheduledJob | None:
+ cur = self.scheduled_job_get(job_id=job_id, tenant_id=tenant_id)
+ if not cur:
+ return None
+ p = dict(patch or {})
+ name = str(p.get("name") if "name" in p else cur.name)
+ description = str(p.get("description") if "description" in p else cur.description)
+ prompt_text = str(p.get("prompt_text") if "prompt_text" in p else cur.prompt_text)
+ interaction_mode = str(p.get("interaction_mode") if "interaction_mode" in p else cur.interaction_mode)
+ specialist = str(p.get("specialist") if "specialist" in p else cur.specialist)
+ lang = str(p.get("lang") if "lang" in p else cur.lang)
+ schedule_kind = normalize_schedule_kind(
+ str(p.get("schedule_kind") if "schedule_kind" in p else cur.schedule_kind)
+ )
+ schedule_expr = str(p.get("schedule_expr") if "schedule_expr" in p else cur.schedule_expr)
+ tz = str(p.get("timezone") if "timezone" in p else cur.timezone)
+ delivery_json = cur.delivery_json
+ if "delivery" in p and isinstance(p.get("delivery"), dict):
+ delivery_json = json.dumps(p["delivery"], ensure_ascii=False)
+ elif "delivery_json" in p:
+ delivery_json = str(p.get("delivery_json") or "{}")
+ source_session_id = cur.source_session_id
+ if "source_session_id" in p:
+ raw_sid = str(p.get("source_session_id") or "").strip()
+ source_session_id = raw_sid or None
+ status = str(p.get("status") if "status" in p else cur.status)
+ recompute = any(k in p for k in ("schedule_kind", "schedule_expr", "timezone", "status"))
+ next_run_at = cur.next_run_at
+ if recompute and status == "active":
+ next_run_at = compute_next_run_at(
+ schedule_kind=schedule_kind,
+ schedule_expr=schedule_expr,
+ timezone_name=tz,
+ from_dt=None,
+ )
+ elif status != "active":
+ next_run_at = None
+ ts = utc_now_iso()
+ with self._connect() as conn: # type: ignore[attr-defined]
+ conn.execute(
+ """
+ UPDATE scheduled_job SET
+ name = ?, description = ?, prompt_text = ?, interaction_mode = ?, specialist = ?,
+ lang = ?, schedule_kind = ?, schedule_expr = ?, timezone = ?, delivery_json = ?,
+ source_session_id = ?, status = ?, next_run_at = ?, updated_at = ?
+ WHERE id = ? AND tenant_id = ?
+ """,
+ (
+ name,
+ description,
+ prompt_text,
+ interaction_mode,
+ specialist,
+ lang,
+ schedule_kind,
+ schedule_expr,
+ tz,
+ delivery_json,
+ source_session_id,
+ status,
+ next_run_at,
+ ts,
+ str(job_id),
+ str(tenant_id),
+ ),
+ )
+ return self.scheduled_job_get(job_id=job_id, tenant_id=tenant_id)
+
+ def scheduled_job_set_status(self, *, tenant_id: str, job_id: str, status: str) -> bool:
+ cur = self.scheduled_job_get(job_id=job_id, tenant_id=tenant_id)
+ if not cur:
+ return False
+ ts = utc_now_iso()
+ next_run_at = cur.next_run_at
+ if status == "active":
+ next_run_at = compute_next_run_at(
+ schedule_kind=cur.schedule_kind,
+ schedule_expr=cur.schedule_expr,
+ timezone_name=cur.timezone,
+ from_dt=None,
+ )
+ else:
+ next_run_at = None
+ with self._connect() as conn: # type: ignore[attr-defined]
+ cur2 = conn.execute(
+ """
+ UPDATE scheduled_job SET status = ?, next_run_at = ?, updated_at = ?
+ WHERE id = ? AND tenant_id = ?
+ """,
+ (str(status), next_run_at, ts, str(job_id), str(tenant_id)),
+ )
+ return bool(cur2.rowcount)
+
+ def scheduled_job_delete(self, *, tenant_id: str, job_id: str) -> bool:
+ return self.scheduled_job_set_status(tenant_id=tenant_id, job_id=job_id, status="deleted")
+
+ def scheduled_job_list_due(self, *, limit: int = 20, now_iso: str | None = None) -> list[ScheduledJob]:
+ lim = max(1, min(int(limit), 100))
+ now = str(now_iso or utc_now_iso())
+ with self._connect() as conn: # type: ignore[attr-defined]
+ rows = conn.execute(
+ f"""
+ {_JOB_SELECT}
+ WHERE status = 'active' AND next_run_at IS NOT NULL AND next_run_at <= ?
+ ORDER BY next_run_at ASC
+ LIMIT ?
+ """,
+ (now, lim),
+ ).fetchall()
+ return [_row_to_job(r) for r in rows]
+
+ def scheduled_job_mark_run(
+ self,
+ *,
+ job_id: str,
+ tenant_id: str,
+ last_run_status: str,
+ pause_after: bool = False,
+ ) -> None:
+ cur = self.scheduled_job_get(job_id=job_id, tenant_id=tenant_id)
+ if not cur:
+ return
+ ts = utc_now_iso()
+ status = "paused" if pause_after else cur.status
+ with self._connect() as conn: # type: ignore[attr-defined]
+ conn.execute(
+ """
+ UPDATE scheduled_job SET
+ last_run_at = ?, last_run_status = ?, status = ?, updated_at = ?
+ WHERE id = ? AND tenant_id = ?
+ """,
+ (ts, str(last_run_status), status, ts, str(job_id), str(tenant_id)),
+ )
+
+ def scheduled_job_reserve_next_run(self, *, job_id: str, tenant_id: str) -> None:
+ """Advance next_run_at when a run is enqueued to avoid duplicate scheduler ticks."""
+ cur = self.scheduled_job_get(job_id=job_id, tenant_id=tenant_id)
+ if not cur:
+ return
+ ts = utc_now_iso()
+ if str(cur.schedule_kind or "") == "once":
+ with self._connect() as conn: # type: ignore[attr-defined]
+ conn.execute(
+ """
+ UPDATE scheduled_job SET next_run_at = NULL, status = 'paused', updated_at = ?
+ WHERE id = ? AND tenant_id = ?
+ """,
+ (ts, str(job_id), str(tenant_id)),
+ )
+ return
+ next_run_at = compute_next_run_at(
+ schedule_kind=cur.schedule_kind,
+ schedule_expr=cur.schedule_expr,
+ timezone_name=cur.timezone,
+ from_dt=datetime.now(timezone.utc),
+ )
+ with self._connect() as conn: # type: ignore[attr-defined]
+ conn.execute(
+ """
+ UPDATE scheduled_job SET next_run_at = ?, updated_at = ?
+ WHERE id = ? AND tenant_id = ?
+ """,
+ (next_run_at, ts, str(job_id), str(tenant_id)),
+ )
+
+ def scheduled_job_run_create(
+ self,
+ *,
+ job_id: str,
+ tenant_id: str,
+ scheduled_at: str | None = None,
+ status: str = "queued",
+ ) -> ScheduledJobRun:
+ rid = str(uuid.uuid4())
+ ts = utc_now_iso()
+ sched = str(scheduled_at or ts)
+ with self._connect() as conn: # type: ignore[attr-defined]
+ conn.execute(
+ """
+ INSERT INTO scheduled_job_run
+ (id, job_id, tenant_id, status, scheduled_at, started_at, finished_at,
+ session_id, oclaw_task_id, run_id, reply_text, delivery_status_json, error, created_at)
+ VALUES (?, ?, ?, ?, ?, NULL, NULL, NULL, NULL, NULL, '', '{}', '', ?)
+ """,
+ (rid, str(job_id), str(tenant_id), str(status), sched, ts),
+ )
+ got = self.scheduled_job_run_get(run_id=rid, tenant_id=tenant_id)
+ if not got:
+ raise RuntimeError("failed to create scheduled job run")
+ return got
+
+ def scheduled_job_run_get(self, *, run_id: str, tenant_id: str | None = None) -> ScheduledJobRun | None:
+ with self._connect() as conn: # type: ignore[attr-defined]
+ if tenant_id:
+ row = conn.execute(
+ """
+ SELECT id, job_id, tenant_id, status, scheduled_at, started_at, finished_at,
+ session_id, oclaw_task_id, run_id, reply_text, delivery_status_json, error, created_at
+ FROM scheduled_job_run WHERE id = ? AND tenant_id = ?
+ """,
+ (str(run_id), str(tenant_id)),
+ ).fetchone()
+ else:
+ row = conn.execute(
+ """
+ SELECT id, job_id, tenant_id, status, scheduled_at, started_at, finished_at,
+ session_id, oclaw_task_id, run_id, reply_text, delivery_status_json, error, created_at
+ FROM scheduled_job_run WHERE id = ?
+ """,
+ (str(run_id),),
+ ).fetchone()
+ if not row:
+ return None
+ return _row_to_run(row)
+
+ def scheduled_job_run_list(
+ self,
+ *,
+ job_id: str,
+ tenant_id: str,
+ limit: int = 50,
+ offset: int = 0,
+ ) -> list[ScheduledJobRun]:
+ lim = max(1, min(int(limit), 200))
+ off = max(0, int(offset))
+ with self._connect() as conn: # type: ignore[attr-defined]
+ rows = conn.execute(
+ """
+ SELECT id, job_id, tenant_id, status, scheduled_at, started_at, finished_at,
+ session_id, oclaw_task_id, run_id, reply_text, delivery_status_json, error, created_at
+ FROM scheduled_job_run
+ WHERE job_id = ? AND tenant_id = ?
+ ORDER BY created_at DESC
+ LIMIT ? OFFSET ?
+ """,
+ (str(job_id), str(tenant_id), lim, off),
+ ).fetchall()
+ return [_row_to_run(r) for r in rows]
+
+ def scheduled_job_run_update(
+ self,
+ *,
+ run_id: str,
+ tenant_id: str,
+ patch: dict[str, Any],
+ ) -> ScheduledJobRun | None:
+ cur = self.scheduled_job_run_get(run_id=run_id, tenant_id=tenant_id)
+ if not cur:
+ return None
+ p = dict(patch or {})
+ status = str(p.get("status") if "status" in p else cur.status)
+ started_at = p.get("started_at") if "started_at" in p else cur.started_at
+ finished_at = p.get("finished_at") if "finished_at" in p else cur.finished_at
+ session_id = p.get("session_id") if "session_id" in p else cur.session_id
+ oclaw_task_id = p.get("oclaw_task_id") if "oclaw_task_id" in p else cur.oclaw_task_id
+ agent_run_id = p.get("run_id") if "run_id" in p else cur.run_id
+ reply_text = str(p.get("reply_text") if "reply_text" in p else cur.reply_text)
+ delivery_status_json = cur.delivery_status_json
+ if "delivery_status" in p and isinstance(p.get("delivery_status"), dict):
+ delivery_status_json = json.dumps(p["delivery_status"], ensure_ascii=False)
+ elif "delivery_status_json" in p:
+ delivery_status_json = str(p.get("delivery_status_json") or "{}")
+ error = str(p.get("error") if "error" in p else cur.error)
+ with self._connect() as conn: # type: ignore[attr-defined]
+ conn.execute(
+ """
+ UPDATE scheduled_job_run SET
+ status = ?, started_at = ?, finished_at = ?, session_id = ?,
+ oclaw_task_id = ?, run_id = ?, reply_text = ?, delivery_status_json = ?, error = ?
+ WHERE id = ? AND tenant_id = ?
+ """,
+ (
+ status,
+ started_at,
+ finished_at,
+ session_id,
+ oclaw_task_id,
+ agent_run_id,
+ reply_text,
+ delivery_status_json,
+ error,
+ str(run_id),
+ str(tenant_id),
+ ),
+ )
+ return self.scheduled_job_run_get(run_id=run_id, tenant_id=tenant_id)
+
+ def scheduled_job_to_dict(self, job: ScheduledJob) -> dict[str, Any]:
+ delivery: dict[str, Any] = {}
+ try:
+ raw = json.loads(job.delivery_json or "{}")
+ if isinstance(raw, dict):
+ delivery = raw
+ except Exception:
+ delivery = {}
+ return {
+ "id": job.id,
+ "tenant_id": job.tenant_id,
+ "name": job.name,
+ "description": job.description,
+ "status": job.status,
+ "schedule_kind": job.schedule_kind,
+ "schedule_expr": job.schedule_expr,
+ "timezone": job.timezone,
+ "prompt_text": job.prompt_text,
+ "interaction_mode": job.interaction_mode,
+ "specialist": job.specialist,
+ "lang": job.lang,
+ "delivery": delivery,
+ "source_session_id": job.source_session_id,
+ "created_by_user_id": job.created_by_user_id,
+ "source": job.source,
+ "next_run_at": job.next_run_at,
+ "last_run_at": job.last_run_at,
+ "last_run_status": job.last_run_status,
+ "created_at": job.created_at,
+ "updated_at": job.updated_at,
+ }
+
+ def scheduled_job_run_to_dict(self, run: ScheduledJobRun) -> dict[str, Any]:
+ delivery_status: dict[str, Any] = {}
+ try:
+ raw = json.loads(run.delivery_status_json or "{}")
+ if isinstance(raw, dict):
+ delivery_status = raw
+ except Exception:
+ delivery_status = {}
+ return {
+ "id": run.id,
+ "job_id": run.job_id,
+ "tenant_id": run.tenant_id,
+ "status": run.status,
+ "scheduled_at": run.scheduled_at,
+ "started_at": run.started_at,
+ "finished_at": run.finished_at,
+ "session_id": run.session_id,
+ "oclaw_task_id": run.oclaw_task_id,
+ "run_id": run.run_id,
+ "reply_text": run.reply_text,
+ "delivery_status": delivery_status,
+ "error": run.error,
+ "created_at": run.created_at,
+ }
+
+
+__all__ = [
+ "ScheduledJob",
+ "ScheduledJobRun",
+ "ScheduledJobStoreMixin",
+ "SCHEDULED_JOB_DDL",
+ "SCHEDULED_JOB_RUN_DDL",
+]
diff --git a/svc/persistence/sqlite_store.py b/svc/persistence/sqlite_store.py
index 8e8f8556..2043d9d3 100644
--- a/svc/persistence/sqlite_store.py
+++ b/svc/persistence/sqlite_store.py
@@ -20,6 +20,7 @@ from sqlalchemy.exc import IntegrityError
from svc.persistence.pg_adapter import PgConnShim, connect_postgres
from svc.persistence.pg_compat import scrub_nul_bytes_from_jsonable, scrub_nul_bytes_from_text
+from svc.persistence.scheduled_job_store import ScheduledJobStoreMixin
if sys.platform == "win32":
import ctypes
@@ -297,7 +298,7 @@ def _decode_secret(secret_text: str) -> str:
raise _CryptoError("未知的密钥编码格式")
-class SqliteStore:
+class SqliteStore(ScheduledJobStoreMixin):
@staticmethod
def _cap_json_for_log(obj: Any, *, max_chars: int, keep_keys: tuple[str, ...] = ("ok", "error_code", "error")) -> Any:
cap = max(2000, int(max_chars or 0))
@@ -677,6 +678,7 @@ class SqliteStore:
conn.execute(
"CREATE INDEX IF NOT EXISTS idx_channel_outbound_pending ON channel_outbound_message(channel, account_id, status, created_at)"
)
+ self.ensure_scheduled_job_tables(conn)
conn.execute(
"""
CREATE TABLE IF NOT EXISTS todo_item (
@@ -1266,6 +1268,7 @@ class SqliteStore:
conn.execute(
"CREATE INDEX IF NOT EXISTS idx_channel_outbound_pending ON channel_outbound_message(channel, account_id, status, created_at)"
)
+ self.ensure_scheduled_job_tables(conn)
self._seed_builtin_llm_profiles(conn)
self._seed_default_permissions(conn)
conn.execute(
@@ -4713,6 +4716,186 @@ class SqliteStore:
for r in rows
]
+ @staticmethod
+ def _channel_context_token_key(
+ *,
+ tenant_id: str,
+ channel: str,
+ account_id: str,
+ external_chat_id: str,
+ ) -> str:
+ return (
+ f"channel_ctx_token:{str(tenant_id or '').strip()}:"
+ f"{str(channel or '').strip().lower()}:"
+ f"{str(account_id or '').strip()}:"
+ f"{str(external_chat_id or '').strip()}"
+ )
+
+ def set_channel_context_token(
+ self,
+ *,
+ tenant_id: str,
+ channel: str,
+ account_id: str,
+ external_chat_id: str,
+ context_token: str,
+ ) -> None:
+ tok = str(context_token or "").strip()
+ chat_id = str(external_chat_id or "").strip()
+ if not tok or not chat_id:
+ return
+ self.set_setting(
+ self._channel_context_token_key(
+ tenant_id=tenant_id,
+ channel=channel,
+ account_id=account_id,
+ external_chat_id=chat_id,
+ ),
+ tok,
+ )
+
+ def get_channel_context_token(
+ self,
+ *,
+ tenant_id: str,
+ channel: str,
+ account_id: str,
+ external_chat_id: str,
+ ) -> str:
+ chat_id = str(external_chat_id or "").strip()
+ if not chat_id:
+ return ""
+ return str(
+ self.get_setting(
+ self._channel_context_token_key(
+ tenant_id=tenant_id,
+ channel=channel,
+ account_id=account_id,
+ external_chat_id=chat_id,
+ )
+ )
+ or ""
+ ).strip()
+
+ def get_channel_context_token_fuzzy(
+ self,
+ *,
+ tenant_id: str,
+ channel: str,
+ account_id: str,
+ external_chat_id: str,
+ ) -> str:
+ chat_id = str(external_chat_id or "").strip()
+ if not chat_id:
+ return ""
+ channels = []
+ for ch in (channel, "wechat", "weixin"):
+ c = str(ch or "").strip().lower()
+ if c and c not in channels:
+ channels.append(c)
+ account_ids: list[str] = []
+ for aid in (account_id, ""):
+ a = str(aid or "").strip()
+ if a not in account_ids:
+ account_ids.append(a)
+ for ch in channels:
+ for aid in account_ids:
+ tok = self.get_channel_context_token(
+ tenant_id=tenant_id,
+ channel=ch,
+ account_id=aid,
+ external_chat_id=chat_id,
+ )
+ if tok:
+ return tok
+ return ""
+
+ def lookup_channel_session_by_chat_v2(
+ self,
+ *,
+ tenant_id: str,
+ channel: str,
+ external_chat_id: str,
+ ) -> dict[str, Any] | None:
+ chat_id = str(external_chat_id or "").strip()
+ tid = str(tenant_id or "").strip()
+ if not chat_id or not tid:
+ return None
+ channels = []
+ for ch in (channel, "wechat", "weixin"):
+ c = str(ch or "").strip().lower()
+ if c and c not in channels:
+ channels.append(c)
+ with self._connect() as conn:
+ for ch in channels:
+ row = conn.execute(
+ """
+ SELECT tenant_id, channel, account_id, external_chat_id, external_user_id, session_id
+ FROM channel_session_v2
+ WHERE tenant_id = ? AND channel = ? AND external_chat_id = ?
+ ORDER BY created_at DESC
+ LIMIT 1
+ """,
+ (tid, ch, chat_id),
+ ).fetchone()
+ if row:
+ return {
+ "tenant_id": str(row["tenant_id"] or ""),
+ "channel": str(row["channel"] or ""),
+ "account_id": str(row["account_id"] or ""),
+ "external_chat_id": str(row["external_chat_id"] or ""),
+ "external_user_id": str(row["external_user_id"] or ""),
+ "session_id": str(row["session_id"] or ""),
+ }
+ return None
+
+ def lookup_channel_session_by_session_id(
+ self,
+ *,
+ tenant_id: str,
+ session_id: str,
+ ) -> dict[str, Any] | None:
+ sid = str(session_id or "").strip()
+ tid = str(tenant_id or "").strip()
+ if not sid or not tid:
+ return None
+ with self._connect() as conn:
+ row = conn.execute(
+ """
+ SELECT tenant_id, channel, account_id, external_chat_id, external_user_id
+ FROM channel_session_v2
+ WHERE tenant_id = ? AND session_id = ?
+ LIMIT 1
+ """,
+ (tid, sid),
+ ).fetchone()
+ if row:
+ return {
+ "tenant_id": str(row["tenant_id"] or ""),
+ "channel": str(row["channel"] or ""),
+ "account_id": str(row["account_id"] or ""),
+ "external_chat_id": str(row["external_chat_id"] or ""),
+ "external_user_id": str(row["external_user_id"] or ""),
+ }
+ row = conn.execute(
+ """
+ SELECT tenant_id, channel, external_chat_id, external_user_id
+ FROM channel_session
+ WHERE tenant_id = ? AND session_id = ?
+ LIMIT 1
+ """,
+ (tid, sid),
+ ).fetchone()
+ if not row:
+ return None
+ return {
+ "tenant_id": str(row["tenant_id"] or ""),
+ "channel": str(row["channel"] or ""),
+ "account_id": "",
+ "external_chat_id": str(row["external_chat_id"] or ""),
+ "external_user_id": str(row["external_user_id"] or ""),
+ }
+
def get_or_create_channel_session(
self,
*,
@@ -5446,18 +5629,68 @@ class SqliteStore:
).fetchall()
return [
{
- "id": str(r[0] or ""),
- "tenant_id": str(r[1] or ""),
- "channel": str(r[2] or ""),
- "account_id": str(r[3] or ""),
- "chat_id": str(r[4] or ""),
- "text": str(r[5] or ""),
- "source": str(r[6] or ""),
- "created_at": str(r[7] or ""),
+ "id": str(r["id"] or ""),
+ "tenant_id": str(r["tenant_id"] or ""),
+ "channel": str(r["channel"] or ""),
+ "account_id": str(r["account_id"] or ""),
+ "chat_id": str(r["chat_id"] or ""),
+ "text": str(r["text"] or ""),
+ "source": str(r["source"] or ""),
+ "created_at": str(r["created_at"] or ""),
}
for r in rows
]
+ def list_pending_weixin_outbound_messages(
+ self,
+ *,
+ account_id: str,
+ limit: int = 20,
+ ) -> list[dict[str, Any]]:
+ lim = max(1, min(int(limit), 100))
+ aid = str(account_id or "").strip()
+ with self._connect() as conn:
+ rows = conn.execute(
+ """
+ SELECT id, tenant_id, channel, account_id, chat_id, text, source, created_at
+ FROM channel_outbound_message
+ WHERE channel IN ('wechat', 'weixin') AND status = 'pending'
+ AND (
+ account_id = ?
+ OR account_id = '' OR account_id = 'weixin-default'
+ OR ? = '' OR ? = 'weixin-default'
+ )
+ ORDER BY created_at ASC
+ LIMIT ?
+ """,
+ (aid, aid, aid, lim),
+ ).fetchall()
+ out: list[dict[str, Any]] = []
+ for r in rows:
+ source = str(r["source"] or "")
+ meta = {}
+ if source.startswith("{"):
+ try:
+ parsed = json.loads(source)
+ if isinstance(parsed, dict):
+ meta = parsed
+ except Exception:
+ meta = {}
+ out.append(
+ {
+ "id": str(r["id"] or ""),
+ "tenant_id": str(r["tenant_id"] or ""),
+ "channel": str(r["channel"] or ""),
+ "account_id": str(r["account_id"] or ""),
+ "chat_id": str(r["chat_id"] or ""),
+ "text": str(r["text"] or ""),
+ "source": source,
+ "context_token": str(meta.get("context_token") or ""),
+ "created_at": str(r["created_at"] or ""),
+ }
+ )
+ return out
+
def ack_channel_outbound_message(
self,
*,
diff --git a/tests/test_admin_scheduled_jobs_api.py b/tests/test_admin_scheduled_jobs_api.py
new file mode 100644
index 00000000..6754028f
--- /dev/null
+++ b/tests/test_admin_scheduled_jobs_api.py
@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import hashlib
+import os
+import tempfile
+import unittest
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+from fastapi.testclient import TestClient
+
+from interfaces.http.fastapi_app import create_app
+from svc.persistence.assistant_store import reset_assistant_store_singleton
+from svc.persistence.sqlite_store import SqliteStore
+
+
+class AdminScheduledJobsApiTests(unittest.TestCase):
+ def setUp(self) -> None:
+ self._tmp = tempfile.TemporaryDirectory(ignore_cleanup_errors=True)
+ self.db = Path(self._tmp.name) / "sched_admin.sqlite"
+ os.environ["OPS_ASSISTANT_DB_PATH"] = str(self.db)
+ os.environ["OPS_ASSISTANT_PASSWORD"] = "test-admin-pass"
+ os.environ["AIA_ASSISTANT_DB_BACKEND"] = "sqlite"
+ reset_assistant_store_singleton()
+ self.store = SqliteStore(str(self.db))
+ t1 = self.store.create_tenant("TeamA")
+ self.tenant_id = str(t1["id"])
+ admin = self.store.create_user_account(
+ tenant_id=self.tenant_id,
+ username="administrator",
+ display_name="Admin",
+ role="owner",
+ password_hash=hashlib.sha256("test-admin-pass".encode("utf-8")).hexdigest(),
+ is_active=True,
+ )
+ self.user_id = str(admin["id"])
+ self.client = TestClient(create_app())
+ self.client.post("/admin/api/auth/bootstrap", json={})
+
+ def tearDown(self) -> None:
+ reset_assistant_store_singleton()
+ self._tmp.cleanup()
+
+ def _login(self) -> str:
+ resp = self.client.post(
+ "/admin/api/auth/login",
+ json={
+ "tenant_id": self.tenant_id,
+ "username": "administrator",
+ "password": "test-admin-pass",
+ "purpose": "console",
+ },
+ )
+ data = resp.json()
+ self.assertTrue(data.get("ok"), data)
+ return str(data.get("token") or "")
+
+ def test_scheduled_jobs_crud(self) -> None:
+ token = self._login()
+ headers = {"authorization": f"Bearer {token}"}
+ once_at = (datetime.now(timezone.utc) + timedelta(hours=1)).isoformat()
+ create = self.client.post(
+ "/admin/api/scheduled-jobs",
+ headers=headers,
+ json={
+ "name": "Test job",
+ "prompt_text": "Say hello",
+ "schedule_kind": "once",
+ "schedule_expr": once_at,
+ "specialist": "generalist",
+ },
+ )
+ self.assertEqual(create.status_code, 200, create.text)
+ body = create.json()
+ self.assertTrue(body.get("ok"), body)
+ job_id = str((body.get("job") or {}).get("id") or "")
+ self.assertTrue(job_id)
+
+ listed = self.client.get("/admin/api/scheduled-jobs", headers=headers)
+ self.assertTrue(listed.json().get("ok"))
+ self.assertGreaterEqual(len(listed.json().get("items") or []), 1)
+
+ pause = self.client.post(f"/admin/api/scheduled-jobs/{job_id}/pause", headers=headers, json={})
+ self.assertTrue(pause.json().get("ok"))
+
+ resume = self.client.post(f"/admin/api/scheduled-jobs/{job_id}/resume", headers=headers, json={})
+ self.assertTrue(resume.json().get("ok"))
+
+ runs = self.client.get(f"/admin/api/scheduled-jobs/{job_id}/runs", headers=headers)
+ self.assertTrue(runs.json().get("ok"))
+
+ patch = self.client.patch(
+ f"/admin/api/scheduled-jobs/{job_id}",
+ headers=headers,
+ json={
+ "name": "Updated job",
+ "schedule_kind": "interval",
+ "schedule_expr": "7200",
+ "prompt_text": "Stand up hourly",
+ "specialist": "generalist",
+ },
+ )
+ self.assertEqual(patch.status_code, 200, patch.text)
+ patched = patch.json()
+ self.assertTrue(patched.get("ok"), patched)
+ job = patched.get("job") or {}
+ self.assertEqual(str(job.get("name") or ""), "Updated job")
+ self.assertEqual(str(job.get("schedule_kind") or ""), "interval")
+ self.assertEqual(str(job.get("schedule_expr") or ""), "7200")
+ self.assertEqual(str(job.get("prompt_text") or ""), "Stand up hourly")
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/tests/test_gateway_cron_service.py b/tests/test_gateway_cron_service.py
new file mode 100644
index 00000000..0086a9da
--- /dev/null
+++ b/tests/test_gateway_cron_service.py
@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+import os
+import tempfile
+import unittest
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+from interfaces.gateway.http_adapter import dispatch_gateway_http_method
+from svc.persistence.assistant_store import reset_assistant_store_singleton
+from svc.persistence.sqlite_store import SqliteStore
+
+
+class GatewayCronServiceTests(unittest.TestCase):
+ def setUp(self) -> None:
+ self._tmp = tempfile.TemporaryDirectory(ignore_cleanup_errors=True)
+ self.db = Path(self._tmp.name) / "cron.sqlite"
+ os.environ["OPS_ASSISTANT_DB_PATH"] = str(self.db)
+ os.environ["AIA_ASSISTANT_DB_BACKEND"] = "sqlite"
+ reset_assistant_store_singleton()
+ self.store = SqliteStore(str(self.db))
+ t = self.store.create_tenant("default")
+ self.tenant_id = str(t["id"])
+
+ def tearDown(self) -> None:
+ reset_assistant_store_singleton()
+ self._tmp.cleanup()
+
+ def test_cron_add_and_list(self) -> None:
+ once_at = (datetime.now(timezone.utc) + timedelta(hours=2)).isoformat()
+ add = dispatch_gateway_http_method(
+ "cron.add",
+ {
+ "name": "gw job",
+ "schedule": once_at,
+ "schedule_kind": "once",
+ "tenant_id": self.tenant_id,
+ "prompt": "hello",
+ },
+ )
+ self.assertTrue(add.get("ok"), add)
+ lst = dispatch_gateway_http_method("cron.list", {"tenant_id": self.tenant_id})
+ self.assertTrue(lst.get("ok"), lst)
+ payload = lst.get("payload") or {}
+ self.assertGreaterEqual(len(payload.get("items") or []), 1)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/tests/test_schedule_duration_parse.py b/tests/test_schedule_duration_parse.py
new file mode 100644
index 00000000..df3685ca
--- /dev/null
+++ b/tests/test_schedule_duration_parse.py
@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import unittest
+
+from runtime.application.gateway.inbound_service import _parse_schedule_duration_seconds
+
+
+class ScheduleDurationParseTests(unittest.TestCase):
+ def test_minutes(self) -> None:
+ self.assertEqual(_parse_schedule_duration_seconds("5分钟"), 300)
+
+ def test_hours(self) -> None:
+ self.assertEqual(_parse_schedule_duration_seconds("1小时"), 3600)
+
+ def test_seconds(self) -> None:
+ self.assertEqual(_parse_schedule_duration_seconds("120秒"), 120)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/tests/test_schedule_tools.py b/tests/test_schedule_tools.py
new file mode 100644
index 00000000..df7c3082
--- /dev/null
+++ b/tests/test_schedule_tools.py
@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import os
+import tempfile
+import unittest
+from pathlib import Path
+
+from runtime.tools.experts.productivity.schedule_tools import schedule_create_tool, schedule_list_tool
+from svc.persistence.assistant_store import reset_assistant_store_singleton
+from svc.persistence.sqlite_store import SqliteStore
+
+
+class ScheduleToolsTests(unittest.TestCase):
+ def setUp(self) -> None:
+ self._tmp = tempfile.TemporaryDirectory(ignore_cleanup_errors=True)
+ self.db = Path(self._tmp.name) / "tools.sqlite"
+ os.environ["OPS_ASSISTANT_DB_PATH"] = str(self.db)
+ os.environ["AIA_ASSISTANT_DB_BACKEND"] = "sqlite"
+ reset_assistant_store_singleton()
+ self.store = SqliteStore(str(self.db))
+ t = self.store.create_tenant("Team")
+ self.tenant_id = str(t["id"])
+ user = self.store.create_user_account(
+ tenant_id=self.tenant_id,
+ username="administrator",
+ display_name="Admin",
+ role="owner",
+ password_hash="x",
+ is_active=True,
+ )
+ self.user_id = str(user["id"])
+
+ def tearDown(self) -> None:
+ reset_assistant_store_singleton()
+ self._tmp.cleanup()
+
+ def test_schedule_create_and_list(self) -> None:
+ create = schedule_create_tool()
+ out = create.handler(
+ {
+ "tenant_id": self.tenant_id,
+ "owner_user_id": self.user_id,
+ "name": "Reminder",
+ "prompt_text": "Check inbox",
+ "schedule_kind": "interval",
+ "schedule_expr": "900",
+ "specialist": "ops",
+ "interaction_mode": "expert",
+ }
+ )
+ self.assertTrue(out.get("ok"), out)
+ lst = schedule_list_tool()
+ listed = lst.handler({"tenant_id": self.tenant_id})
+ self.assertTrue(listed.get("ok"))
+ self.assertEqual(len(listed.get("items") or []), 1)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/tests/test_scheduler_ephemeral_context.py b/tests/test_scheduler_ephemeral_context.py
new file mode 100644
index 00000000..9ba71ef1
--- /dev/null
+++ b/tests/test_scheduler_ephemeral_context.py
@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+import os
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import MagicMock
+
+from runtime.scheduler.worker_turn import resolve_scheduled_outbound_text
+from svc.persistence.sqlite_store import SqliteStore
+
+
+class EphemeralUserContextTests(unittest.TestCase):
+ def setUp(self) -> None:
+ self._tmp = tempfile.TemporaryDirectory(ignore_cleanup_errors=True)
+ self.db = Path(self._tmp.name) / "ctx.sqlite"
+ os.environ["OPS_ASSISTANT_DB_PATH"] = str(self.db)
+ self.store = SqliteStore(str(self.db))
+ sess = self.store.create_session("test")
+ self.session_id = str(sess.id)
+
+ def tearDown(self) -> None:
+ self._tmp.cleanup()
+
+ def test_build_model_context_injects_ephemeral_user_text(self) -> None:
+ from runtime.direct_loop import _build_model_context
+ from svc.llm.chat_models import RuleBasedChatModel
+
+ msgs = _build_model_context(
+ store=self.store,
+ session_id=self.session_id,
+ max_messages=20,
+ system_prompt="sys",
+ model=RuleBasedChatModel(),
+ lang="zh",
+ memory_context=None,
+ trace_id=None,
+ parent_span_id=None,
+ user_text="【定时主动提醒】站起来",
+ active_turn_uuid="turn-sched-1",
+ )
+ roles = [str(m.get("role") or "") for m in msgs]
+ self.assertIn("user", roles)
+ self.assertEqual(str(msgs[-1].get("content") or ""), "【定时主动提醒】站起来")
+ rows = self.store.get_messages(session_id=self.session_id, limit=10)
+ self.assertEqual(len(rows), 0)
+
+
+class ScheduledOutboundFallbackTests(unittest.TestCase):
+ def test_uses_prompt_when_model_reply_empty(self) -> None:
+ text = resolve_scheduled_outbound_text(
+ payload={"prompt_text": "站起来活动一下"},
+ reply_text="",
+ )
+ self.assertIn("站起来活动一下", text)
+ self.assertTrue(text.startswith("⏰"))
+
+ def test_keeps_model_reply_when_present(self) -> None:
+ text = resolve_scheduled_outbound_text(
+ payload={"prompt_text": "站起来活动一下"},
+ reply_text="该起来啦！",
+ )
+ self.assertEqual(text, "该起来啦！")
+
+
+class ScheduledAssistantPersistTests(unittest.TestCase):
+ def setUp(self) -> None:
+ self._tmp = tempfile.TemporaryDirectory(ignore_cleanup_errors=True)
+ self.db = Path(self._tmp.name) / "persist.sqlite"
+ os.environ["OPS_ASSISTANT_DB_PATH"] = str(self.db)
+ self.store = SqliteStore(str(self.db))
+ sess = self.store.create_session("sched")
+ self.session_id = str(sess.id)
+
+ def tearDown(self) -> None:
+ self._tmp.cleanup()
+
+ def test_finalize_persists_assistant_when_missing(self) -> None:
+ from runtime.scheduler.worker_turn import finalize_scheduled_turn_success
+
+ task = MagicMock()
+ task.task_type = "scheduled_turn"
+ payload = {
+ "tenant_id": "t1",
+ "job_id": "",
+ "run_id_scheduled": "",
+ "session_id": self.session_id,
+ "prompt_text": "休息",
+ "delivery": {"weixin": {"enabled": False}},
+ "resolved_channel": "admin_chat",
+ }
+ with unittest.mock.patch(
+ "runtime.scheduler.channel_delivery.deliver_scheduled_reply",
+ return_value={"ok": True, "skipped": True},
+ ):
+ finalize_scheduled_turn_success(
+ store=self.store,
+ task=task,
+ payload={
+ **payload,
+ "session_id": self.session_id,
+ },
+ base_result={"reply_text": "", "turn_uuid": "tu-1"},
+ )
+ rows = self.store.get_messages(session_id=self.session_id, limit=10)
+ self.assertEqual(len(rows), 1)
+ self.assertEqual(str(rows[0].role), "assistant")
+ self.assertEqual(str(getattr(rows[0], "event_type", "") or ""), "assistant_text")
+ self.assertIn("休息", str(rows[0].content or ""))
+
+ def test_updates_empty_assistant_for_same_turn(self) -> None:
+ from runtime.scheduler.worker_turn import _persist_scheduled_assistant_reply
+
+ self.store.add_message(
+ session_id=self.session_id,
+ role="assistant",
+ content="",
+ turn_uuid="tu-empty",
+ event_type="assistant_text",
+ )
+ _persist_scheduled_assistant_reply(
+ self.store,
+ session_id=self.session_id,
+ turn_uuid="tu-empty",
+ reply_text="⏰ 提醒：站起来",
+ )
+ rows = self.store.get_messages(session_id=self.session_id, limit=10)
+ self.assertEqual(len(rows), 1)
+ self.assertIn("站起来", str(rows[0].content or ""))
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/tests/test_scheduler_expressions.py b/tests/test_scheduler_expressions.py
new file mode 100644
index 00000000..75569174
--- /dev/null
+++ b/tests/test_scheduler_expressions.py
@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+import os
+import tempfile
+import unittest
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+from runtime.scheduler.expressions import compute_next_run_at, normalize_schedule_kind
+from svc.persistence.sqlite_store import SqliteStore
+
+
+class SchedulerExpressionsTests(unittest.TestCase):
+ def test_normalize_schedule_kind(self) -> None:
+ self.assertEqual(normalize_schedule_kind("CRON"), "cron")
+ self.assertEqual(normalize_schedule_kind("bad"), "cron")
+
+ def test_interval_next_run(self) -> None:
+ base = datetime(2026, 6, 26, 10, 0, 0, tzinfo=timezone.utc)
+ nxt = compute_next_run_at(
+ schedule_kind="interval",
+ schedule_expr="120",
+ timezone_name="Asia/Shanghai",
+ from_dt=base,
+ )
+ self.assertEqual(nxt, (base + timedelta(seconds=120)).isoformat())
+
+ def test_once_future(self) -> None:
+ future = datetime.now(timezone.utc) + timedelta(hours=2)
+ nxt = compute_next_run_at(
+ schedule_kind="once",
+ schedule_expr=future.isoformat(),
+ timezone_name="Asia/Shanghai",
+ )
+ self.assertIsNotNone(nxt)
+
+
+class ScheduledJobStoreTests(unittest.TestCase):
+ def setUp(self) -> None:
+ self._tmp = tempfile.TemporaryDirectory(ignore_cleanup_errors=True)
+ self.db = Path(self._tmp.name) / "sched.sqlite"
+ os.environ["OPS_ASSISTANT_DB_PATH"] = str(self.db)
+ self.store = SqliteStore(str(self.db))
+ t = self.store.create_tenant("Team")
+ self.tenant_id = str(t["id"])
+ user = self.store.create_user_account(
+ tenant_id=self.tenant_id,
+ username="administrator",
+ display_name="Admin",
+ role="owner",
+ password_hash="x",
+ is_active=True,
+ )
+ self.user_id = str(user["id"])
+
+ def tearDown(self) -> None:
+ self._tmp.cleanup()
+
+ def test_row_to_job_dict_row(self) -> None:
+ from svc.persistence.scheduled_job_store import _row_to_job
+
+ row = {
+ "id": "j1",
+ "tenant_id": self.tenant_id,
+ "name": "Test",
+ "description": "",
+ "status": "active",
+ "schedule_kind": "interval",
+ "schedule_expr": "300",
+ "timezone": "Asia/Shanghai",
+ "prompt_text": "ping",
+ "interaction_mode": "expert",
+ "specialist": "generalist",
+ "lang": "zh",
+ "delivery_json": "{}",
+ "source_session_id": None,
+ "created_by_user_id": self.user_id,
+ "source": "chat",
+ "next_run_at": "2026-06-26T10:00:00+00:00",
+ "last_run_at": None,
+ "last_run_status": "",
+ "created_at": "2026-06-26T09:00:00+00:00",
+ "updated_at": "2026-06-26T09:00:00+00:00",
+ }
+ job = _row_to_job(row)
+ self.assertEqual(job.id, "j1")
+ self.assertEqual(job.name, "Test")
+ job = self.store.scheduled_job_create(
+ tenant_id=self.tenant_id,
+ name="Daily report",
+ prompt_text="Summarize alarms",
+ schedule_kind="interval",
+ schedule_expr="3600",
+ created_by_user_id=self.user_id,
+ )
+ self.assertEqual(job.status, "active")
+ self.assertTrue(job.next_run_at)
+ rows = self.store.scheduled_job_list(tenant_id=self.tenant_id)
+ self.assertEqual(len(rows), 1)
+ ok = self.store.scheduled_job_set_status(
+ tenant_id=self.tenant_id,
+ job_id=job.id,
+ status="paused",
+ )
+ self.assertTrue(ok)
+ due = self.store.scheduled_job_list_due(limit=10)
+ self.assertEqual(due, [])
+
+ def test_run_record(self) -> None:
+ job = self.store.scheduled_job_create(
+ tenant_id=self.tenant_id,
+ name="Once",
+ prompt_text="Ping",
+ schedule_kind="once",
+ schedule_expr=(datetime.now(timezone.utc) + timedelta(minutes=5)).isoformat(),
+ created_by_user_id=self.user_id,
+ )
+ run = self.store.scheduled_job_run_create(job_id=job.id, tenant_id=self.tenant_id)
+ self.assertEqual(run.status, "queued")
+ updated = self.store.scheduled_job_run_update(
+ run_id=run.id,
+ tenant_id=self.tenant_id,
+ patch={"status": "success", "reply_text": "ok"},
+ )
+ self.assertIsNotNone(updated)
+ self.assertEqual(str(updated.reply_text), "ok")
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/tests/test_scheduler_proactive_delivery.py b/tests/test_scheduler_proactive_delivery.py
new file mode 100644
index 00000000..1318580b
--- /dev/null
+++ b/tests/test_scheduler_proactive_delivery.py
@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+import os
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+from runtime.scheduler.channel_delivery import deliver_scheduled_reply
+from runtime.scheduler.cron_service import build_delivery_for_session
+from runtime.scheduler.session_resolver import resolve_scheduled_session
+from runtime.scheduler.turn_text import build_scheduled_turn_instruction
+from svc.persistence.sqlite_store import SqliteStore
+
+
+class ScheduledTurnTextTests(unittest.TestCase):
+ def test_instruction_is_internal_not_user_facing(self) -> None:
+ text = build_scheduled_turn_instruction(
+ prompt_text="站起来活动一下",
+ mode="scheduled",
+ lang="zh",
+ )
+ self.assertIn("提醒意图", text)
+ self.assertNotIn("[scheduled:", text)
+
+
+class ScheduledSessionResolverTests(unittest.TestCase):
+ def setUp(self) -> None:
+ self._tmp = tempfile.TemporaryDirectory(ignore_cleanup_errors=True)
+ self.db = Path(self._tmp.name) / "sched.sqlite"
+ os.environ["OPS_ASSISTANT_DB_PATH"] = str(self.db)
+ self.store = SqliteStore(str(self.db))
+ t = self.store.create_tenant("Team")
+ self.tenant_id = str(t["id"])
+ admin = self.store.create_user_account(
+ tenant_id=self.tenant_id,
+ username="administrator",
+ display_name="Admin",
+ role="owner",
+ password_hash="x",
+ is_active=True,
+ )
+ self.admin_id = str(admin["id"])
+ sess = self.store.create_session("WeChat session")
+ self.session_id = str(sess.id)
+ self.store.ensure_ui_session_owner(
+ session_id=self.session_id,
+ tenant_id=self.tenant_id,
+ user_id=self.admin_id,
+ )
+ with self.store._connect() as conn:
+ conn.execute(
+ """
+ INSERT INTO channel_session_v2
+ (tenant_id, channel, account_id, external_chat_id, external_user_id, session_id, created_at)
+ VALUES (?, ?, ?, ?, ?, ?, datetime('now'))
+ """,
+ (self.tenant_id, "weixin", "weixin-default", "wx-user-123", "wx-user-123", self.session_id),
+ )
+
+ def tearDown(self) -> None:
+ self._tmp.cleanup()
+
+ def test_source_session_preserves_weixin_delivery_target(self) -> None:
+ job = MagicMock()
+ job.tenant_id = self.tenant_id
+ job.delivery_json = '{"weixin":{"enabled":true}}'
+ job.source_session_id = self.session_id
+ job.name = "rest"
+ resolved = resolve_scheduled_session(store=self.store, job=job, created_by_user_id=self.admin_id)
+ self.assertEqual(resolved.channel, "weixin")
+ self.assertEqual(resolved.external_chat_id, "wx-user-123")
+
+
+class ScheduledDeliveryChannelTests(unittest.TestCase):
+ def setUp(self) -> None:
+ self._tmp = tempfile.TemporaryDirectory(ignore_cleanup_errors=True)
+ self.db = Path(self._tmp.name) / "sched.sqlite"
+ os.environ["OPS_ASSISTANT_DB_PATH"] = str(self.db)
+ self.store = SqliteStore(str(self.db))
+ t = self.store.create_tenant("Team")
+ self.tenant_id = str(t["id"])
+
+ def tearDown(self) -> None:
+ self._tmp.cleanup()
+
+ def test_whatsapp_session_disables_weixin_delivery(self) -> None:
+ sess = self.store.create_session("WA session")
+ session_id = str(sess.id)
+ with self.store._connect() as conn:
+ conn.execute(
+ """
+ INSERT INTO channel_session_v2
+ (tenant_id, channel, account_id, external_chat_id, external_user_id, session_id, created_at)
+ VALUES (?, ?, ?, ?, ?, ?, datetime('now'))
+ """,
+ (self.tenant_id, "whatsapp", "wa-default", "15551234567@s.whatsapp.net", "15551234567", session_id),
+ )
+ delivery = build_delivery_for_session(
+ self.store,
+ tenant_id=self.tenant_id,
+ session_id=session_id,
+ )
+ self.assertTrue(delivery["whatsapp"]["enabled"])
+ self.assertEqual(delivery["whatsapp"]["chat_id"], "15551234567@s.whatsapp.net")
+ self.assertFalse(delivery["weixin"]["enabled"])
+
+ def test_weixin_session_disables_whatsapp_delivery(self) -> None:
+ sess = self.store.create_session("WX session")
+ session_id = str(sess.id)
+ with self.store._connect() as conn:
+ conn.execute(
+ """
+ INSERT INTO channel_session_v2
+ (tenant_id, channel, account_id, external_chat_id, external_user_id, session_id, created_at)
+ VALUES (?, ?, ?, ?, ?, ?, datetime('now'))
+ """,
+ (self.tenant_id, "weixin", "weixin-default", "wx-user-9", "wx-user-9", session_id),
+ )
+ delivery = build_delivery_for_session(
+ self.store,
+ tenant_id=self.tenant_id,
+ session_id=session_id,
+ )
+ self.assertTrue(delivery["weixin"]["enabled"])
+ self.assertFalse(delivery["whatsapp"]["enabled"])
+
+
+class ScheduledDeliveryTests(unittest.TestCase):
+ def setUp(self) -> None:
+ self._tmp = tempfile.TemporaryDirectory(ignore_cleanup_errors=True)
+ self.db = Path(self._tmp.name) / "sched.sqlite"
+ os.environ["OPS_ASSISTANT_DB_PATH"] = str(self.db)
+ self.store = SqliteStore(str(self.db))
+ t = self.store.create_tenant("Team")
+ self.tenant_id = str(t["id"])
+
+ def tearDown(self) -> None:
+ self._tmp.cleanup()
+
+ @patch("runtime.scheduler.channel_delivery.enqueue_weixin_reply")
+ def test_deliver_uses_stored_context_token(self, mock_enqueue: MagicMock) -> None:
+ mock_enqueue.return_value = {"ok": True, "channel": "wechat", "queued": True}
+ self.store.set_channel_context_token(
+ tenant_id=self.tenant_id,
+ channel="wechat",
+ account_id="real-acct",
+ external_chat_id="wx-user-123",
+ context_token="ctx-abc",
+ )
+ sess = self.store.create_session("wx-deliver")
+ session_id = str(sess.id)
+ with self.store._connect() as conn:
+ conn.execute(
+ """
+ INSERT INTO channel_session_v2
+ (tenant_id, channel, account_id, external_chat_id, external_user_id, session_id, created_at)
+ VALUES (?, ?, ?, ?, ?, ?, datetime('now'))
+ """,
+ (self.tenant_id, "wechat", "real-acct", "wx-user-123", "wx-user-123", session_id),
+ )
+ out = deliver_scheduled_reply(
+ self.store,
+ tenant_id=self.tenant_id,
+ reply_text="该起来活动啦",
+ delivery_json='{"weixin":{"enabled":true}}',
+ resolved_channel="wechat",
+ resolved_chat_id="wx-user-123",
+ resolved_account_id="weixin-default",
+ session_id=session_id,
+ )
+ self.assertTrue(out.get("ok"))
+ mock_enqueue.assert_called_once()
+ kwargs = mock_enqueue.call_args.kwargs
+ self.assertEqual(kwargs.get("context_token"), "ctx-abc")
+ self.assertEqual(kwargs.get("chat_id"), "wx-user-123")
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/tests/test_scheduler_viewer_username.py b/tests/test_scheduler_viewer_username.py
new file mode 100644
index 00000000..d46488c2
--- /dev/null
+++ b/tests/test_scheduler_viewer_username.py
@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+import os
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import MagicMock
+
+from runtime.scheduler.session_resolver import resolve_scheduled_viewer_username
+from runtime.scheduler.service import enqueue_scheduled_job_run
+from svc.persistence.sqlite_store import SqliteStore
+
+
+class ResolveScheduledViewerUsernameTests(unittest.TestCase):
+ def setUp(self) -> None:
+ self._tmp = tempfile.TemporaryDirectory(ignore_cleanup_errors=True)
+ self.db = Path(self._tmp.name) / "sched.sqlite"
+ os.environ["OPS_ASSISTANT_DB_PATH"] = str(self.db)
+ self.store = SqliteStore(str(self.db))
+ t = self.store.create_tenant("Team")
+ self.tenant_id = str(t["id"])
+ self.admin = self.store.create_user_account(
+ tenant_id=self.tenant_id,
+ username="administrator",
+ display_name="Admin",
+ role="owner",
+ password_hash="x",
+ is_active=True,
+ )
+ self.member = self.store.create_user_account(
+ tenant_id=self.tenant_id,
+ username="alice",
+ display_name="Alice",
+ role="member",
+ password_hash="x",
+ is_active=True,
+ )
+
+ def tearDown(self) -> None:
+ self._tmp.cleanup()
+
+ def test_weixin_uses_administrator_pool(self) -> None:
+ uname = resolve_scheduled_viewer_username(
+ self.store,
+ tenant_id=self.tenant_id,
+ user_id=str(self.member["id"]),
+ channel="weixin",
+ )
+ self.assertEqual(uname, "administrator")
+
+ def test_admin_chat_uses_job_owner_username(self) -> None:
+ uname = resolve_scheduled_viewer_username(
+ self.store,
+ tenant_id=self.tenant_id,
+ user_id=str(self.member["id"]),
+ channel="admin_chat",
+ )
+ self.assertEqual(uname, "alice")
+
+ def test_enqueue_payload_includes_viewer_username_for_weixin(self) -> None:
+ job = MagicMock()
+ job.tenant_id = self.tenant_id
+ job.id = "job-weixin"
+ job.next_run_at = "2026-06-26T10:00:00+00:00"
+ job.delivery_json = '{"weixin":{"enabled":true}}'
+ job.prompt_text = "stretch"
+ job.lang = "zh"
+ job.interaction_mode = "expert"
+ job.specialist = "generalist"
+ job.created_by_user_id = str(self.member["id"])
+ job.schedule_kind = "interval"
+
+ run = MagicMock()
+ run.id = "run-1"
+ self.store.scheduled_job_run_create = MagicMock(return_value=run) # type: ignore[method-assign]
+ self.store.scheduled_job_run_update = MagicMock() # type: ignore[method-assign]
+ self.store.scheduled_job_reserve_next_run = MagicMock() # type: ignore[method-assign]
+ captured: dict[str, object] = {}
+
+ def _capture_create(**kwargs: object) -> MagicMock:
+ captured.update(kwargs)
+ return MagicMock(id="task-1")
+
+ self.store.oclaw_task_create = _capture_create # type: ignore[method-assign]
+
+ from runtime.scheduler import service as sched_service
+ from runtime.scheduler.session_resolver import ResolvedSession
+
+ resolved = ResolvedSession(
+ session_id="sess-1",
+ tenant_id=self.tenant_id,
+ user_id=str(self.admin["id"]),
+ channel="weixin",
+ account_id="weixin-default",
+ external_chat_id="wx-user-1",
+ external_user_id="wx-user-1",
+ is_group=False,
+ )
+ original_resolve = sched_service.resolve_scheduled_session
+ original_worker = sched_service.ensure_worker_started
+ try:
+ sched_service.resolve_scheduled_session = MagicMock(return_value=resolved)
+ sched_service.ensure_worker_started = MagicMock(return_value="worker-1")
+ enqueue_scheduled_job_run(self.store, job=job, mode="scheduled")
+ finally:
+ sched_service.resolve_scheduled_session = original_resolve
+ sched_service.ensure_worker_started = original_worker
+
+ payload = captured.get("payload")
+ self.assertIsInstance(payload, dict)
+ assert isinstance(payload, dict)
+ self.assertEqual(payload.get("viewer_username"), "administrator")
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/tests/test_tool_context_inject.py b/tests/test_tool_context_inject.py
new file mode 100644
index 00000000..474ae5b0
--- /dev/null
+++ b/tests/test_tool_context_inject.py
@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import os
+import tempfile
+import unittest
+from pathlib import Path
+
+from runtime.tools.context_inject import enrich_tool_arguments
+from runtime.tools.experts.productivity.schedule_tools import schedule_create_tool
+from svc.persistence.assistant_store import reset_assistant_store_singleton
+from svc.persistence.sqlite_store import SqliteStore
+
+
+class ToolContextInjectTests(unittest.TestCase):
+ def setUp(self) -> None:
+ self._tmp = tempfile.TemporaryDirectory(ignore_cleanup_errors=True)
+ self.db = Path(self._tmp.name) / "ctx.sqlite"
+ os.environ["OPS_ASSISTANT_DB_PATH"] = str(self.db)
+ os.environ["AIA_ASSISTANT_DB_BACKEND"] = "sqlite"
+ reset_assistant_store_singleton()
+ self.store = SqliteStore(str(self.db))
+ t = self.store.create_tenant("Team")
+ self.tenant_id = str(t["id"])
+ user = self.store.create_user_account(
+ tenant_id=self.tenant_id,
+ username="administrator",
+ display_name="Admin",
+ role="owner",
+ password_hash="x",
+ is_active=True,
+ )
+ self.user_id = str(user["id"])
+ sess = self.store.create_session_for_user(
+ title="wx",
+ tenant_id=self.tenant_id,
+ user_id=self.user_id,
+ )
+ self.session_id = str(sess.id)
+ self.store.ensure_ui_session_owner(
+ session_id=self.session_id,
+ tenant_id=self.tenant_id,
+ user_id=self.user_id,
+ )
+
+ def tearDown(self) -> None:
+ reset_assistant_store_singleton()
+ self._tmp.cleanup()
+
+ def test_enrich_from_session_owner(self) -> None:
+ out = enrich_tool_arguments(
+ store=self.store,
+ session_id=self.session_id,
+ tool_name="schedule_create",
+ arguments={"name": "x"},
+ )
+ self.assertEqual(out.get("tenant_id"), self.tenant_id)
+ self.assertEqual(out.get("owner_user_id"), self.user_id)
+ self.assertEqual(out.get("session_id"), self.session_id)
+
+ def test_schedule_create_strips_llm_user_id(self) -> None:
+ tool = schedule_create_tool()
+ res = tool.handler(
+ {
+ "session_id": self.session_id,
+ "user_id": "wx_fake_external_id",
+ "name": "Rest",
+ "prompt_text": "提醒休息",
+ "schedule_kind": "interval",
+ "schedule_expr": "300",
+ }
+ )
+ self.assertTrue(res.get("ok"), res)
+
+ def test_tool_runtime_filters_user_id_for_schedule_schema(self) -> None:
+ from runtime.tools.tool_validation import filter_arguments_to_schema
+
+ tool = schedule_create_tool()
+ filtered = filter_arguments_to_schema(
+ tool.parameters,
+ {
+ "user_id": "bad",
+ "name": "x",
+ "prompt_text": "y",
+ "schedule_kind": "interval",
+ "schedule_expr": "60",
+ },
+ )
+ self.assertNotIn("user_id", filtered)
+ self.assertIn("name", filtered)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/tests/test_tool_runtime_schedule_validation.py b/tests/test_tool_runtime_schedule_validation.py
new file mode 100644
index 00000000..541a5b20
--- /dev/null
+++ b/tests/test_tool_runtime_schedule_validation.py
@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import os
+import tempfile
+import unittest
+from pathlib import Path
+
+from runtime.chat.tool_runtime import ToolExecutionContext, ToolExecutor
+from runtime.tools.experts.productivity.schedule_tools import schedule_create_tool
+from runtime.tools.base import ToolRegistry
+from svc.llm.transports.base import LLMToolCall
+from svc.persistence.assistant_store import reset_assistant_store_singleton
+from svc.persistence.sqlite_store import SqliteStore
+
+
+class ToolRuntimeScheduleValidationTests(unittest.TestCase):
+ def setUp(self) -> None:
+ self._tmp = tempfile.TemporaryDirectory(ignore_cleanup_errors=True)
+ self.db = Path(self._tmp.name) / "rt.sqlite"
+ os.environ["OPS_ASSISTANT_DB_PATH"] = str(self.db)
+ os.environ["AIA_ASSISTANT_DB_BACKEND"] = "sqlite"
+ reset_assistant_store_singleton()
+ self.store = SqliteStore(str(self.db))
+ t = self.store.create_tenant("Team")
+ self.tenant_id = str(t["id"])
+ user = self.store.create_user_account(
+ tenant_id=self.tenant_id,
+ username="administrator",
+ display_name="Admin",
+ role="owner",
+ password_hash="x",
+ is_active=True,
+ )
+ self.user_id = str(user["id"])
+ sess = self.store.create_session_for_user(
+ title="wx",
+ tenant_id=self.tenant_id,
+ user_id=self.user_id,
+ )
+ self.session_id = str(sess.id)
+ self.store.ensure_ui_session_owner(
+ session_id=self.session_id,
+ tenant_id=self.tenant_id,
+ user_id=self.user_id,
+ )
+
+ def tearDown(self) -> None:
+ reset_assistant_store_singleton()
+ self._tmp.cleanup()
+
+ def test_execute_schedule_create_with_hallucinated_user_id(self) -> None:
+ reg = ToolRegistry([schedule_create_tool()])
+ ex = ToolExecutor()
+ ctx = ToolExecutionContext(
+ store=self.store,
+ tools=reg,
+ session_id=self.session_id,
+ path_policy_tenant_id=self.tenant_id,
+ path_policy_user_id=self.user_id,
+ )
+ tc = LLMToolCall(
+ id="call1",
+ name="schedule_create",
+ arguments={
+ "user_id": "wechat_external_123",
+ "name": "Break",
+ "prompt_text": "Stand up",
+ "schedule_kind": "interval",
+ "schedule_expr": "300",
+ },
+ )
+ result, _dur = ex._execute_tool(ctx, tc)
+ self.assertTrue(result.get("ok"), result)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/tests/test_weixin_scheduled_delivery.py b/tests/test_weixin_scheduled_delivery.py
new file mode 100644
index 00000000..12bc846c
--- /dev/null
+++ b/tests/test_weixin_scheduled_delivery.py
@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+import os
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+from runtime.scheduler.channel_delivery import enqueue_weixin_reply
+from runtime.scheduler.weixin_delivery import resolve_weixin_delivery_target
+from svc.persistence.sqlite_store import SqliteStore
+
+
+class WeixinBridgePollTests(unittest.TestCase):
+ def test_poll_accepts_wechat_channel_alias(self) -> None:
+ from interfaces.http.weixin_ilink_api import _BRIDGE
+
+ _BRIDGE._events.clear()
+ _BRIDGE._seq = 0
+ _BRIDGE.enqueue_reply(
+ token="",
+ channel="weixin",
+ account_id="acct-1",
+ chat_id="user-1",
+ text="hello",
+ context_token="ctx-1",
+ )
+ msgs, _ = _BRIDGE.poll(token="sidecar-token", cursor=0, channel="wechat", account_id="acct-1")
+ self.assertEqual(len(msgs), 1)
+ self.assertEqual(str(msgs[0].get("text") or ""), "hello")
+
+ def test_poll_accepts_legacy_default_account_id(self) -> None:
+ from interfaces.http.weixin_ilink_api import _BRIDGE
+
+ _BRIDGE._events.clear()
+ _BRIDGE._seq = 0
+ _BRIDGE.enqueue_reply(
+ token="",
+ channel="wechat",
+ account_id="weixin-default",
+ chat_id="user-1",
+ text="hello",
+ context_token="ctx-1",
+ )
+ msgs, _ = _BRIDGE.poll(token="sidecar-token", cursor=0, channel="wechat", account_id="real-acct")
+ self.assertEqual(len(msgs), 1)
+
+
+class WeixinDeliveryTargetTests(unittest.TestCase):
+ def setUp(self) -> None:
+ self._tmp = tempfile.TemporaryDirectory(ignore_cleanup_errors=True)
+ self.db = Path(self._tmp.name) / "wx.sqlite"
+ os.environ["OPS_ASSISTANT_DB_PATH"] = str(self.db)
+ self.store = SqliteStore(str(self.db))
+ t = self.store.create_tenant("Team")
+ self.tenant_id = str(t["id"])
+ sess = self.store.create_session("wx")
+ self.session_id = str(sess.id)
+ with self.store._connect() as conn:
+ conn.execute(
+ """
+ INSERT INTO channel_session_v2
+ (tenant_id, channel, account_id, external_chat_id, external_user_id, session_id, created_at)
+ VALUES (?, ?, ?, ?, ?, ?, datetime('now'))
+ """,
+ (self.tenant_id, "wechat", "real-acct-9", "wx-user-9", "wx-user-9", self.session_id),
+ )
+ self.store.set_channel_context_token(
+ tenant_id=self.tenant_id,
+ channel="wechat",
+ account_id="real-acct-9",
+ external_chat_id="wx-user-9",
+ context_token="ctx-xyz",
+ )
+
+ def tearDown(self) -> None:
+ self._tmp.cleanup()
+
+ def test_resolve_account_and_token_from_session(self) -> None:
+ target = resolve_weixin_delivery_target(
+ self.store,
+ tenant_id=self.tenant_id,
+ session_id=self.session_id,
+ delivery={"weixin": {"enabled": True}},
+ resolved_channel="wechat",
+ resolved_chat_id="",
+ resolved_account_id="weixin-default",
+ )
+ self.assertEqual(target["account_id"], "real-acct-9")
+ self.assertEqual(target["chat_id"], "wx-user-9")
+ self.assertEqual(target["context_token"], "ctx-xyz")
+
+
+class EnqueueWeixinReplyTests(unittest.TestCase):
+ @patch("interfaces.http.weixin_ilink_api.enqueue_weixin_outbound_reply", return_value="7")
+ def test_requires_context_token(self, _mock_enqueue: MagicMock) -> None:
+ out = enqueue_weixin_reply(
+ channel="wechat",
+ account_id="acct",
+ chat_id="user",
+ text="hi",
+ context_token="",
+ )
+ self.assertFalse(out.get("ok"))
+ self.assertEqual(out.get("error"), "context_token_missing")
+ _mock_enqueue.assert_not_called()
+
+ @patch("interfaces.http.weixin_ilink_api.enqueue_weixin_outbound_reply", return_value="8")
+ def test_queues_with_context_token(self, mock_enqueue: MagicMock) -> None:
+ out = enqueue_weixin_reply(
+ channel="wechat",
+ account_id="acct",
+ chat_id="user",
+ text="hi",
+ context_token="ctx-1",
+ )
+ self.assertTrue(out.get("ok"))
+ self.assertTrue(out.get("queued"))
+ mock_enqueue.assert_called_once()
+
+ @patch("interfaces.http.weixin_ilink_api.enqueue_weixin_outbound_reply", return_value="9")
+ def test_persists_durable_outbound_when_store_available(self, mock_enqueue: MagicMock) -> None:
+ tmp = tempfile.TemporaryDirectory(ignore_cleanup_errors=True)
+ db = Path(tmp.name) / "wx.sqlite"
+ os.environ["OPS_ASSISTANT_DB_PATH"] = str(db)
+ store = SqliteStore(str(db))
+ try:
+ out = enqueue_weixin_reply(
+ channel="wechat",
+ account_id="acct",
+ chat_id="user",
+ text="hi",
+ context_token="ctx-1",
+ store=store,
+ tenant_id="t1",
+ )
+ self.assertTrue(out.get("ok"))
+ self.assertTrue(out.get("durable"))
+ pending = store.list_pending_weixin_outbound_messages(account_id="acct", limit=10)
+ self.assertEqual(len(pending), 1)
+ self.assertEqual(str(pending[0].get("context_token") or ""), "ctx-1")
+ mock_enqueue.assert_called_once()
+ finally:
+ tmp.cleanup()
+
+
+if __name__ == "__main__":
+ unittest.main()