loopable / api /tool_groups /automations.py
fsanyoto's picture
Deploy AIOS web (React glide grid + FastAPI slice)
868b75a verified
Raw History Blame
9.74 kB
"""Manage owned Automation definitions through the shared confirmation dispatcher."""
import copy
from fastapi import HTTPException
from core import external_tools, perm_scope
from deps import Session, err
import automation_engine as engine
import external_activity
def _context(ctx, *, write=False):
if not isinstance(ctx, external_tools.ToolContext) or not isinstance(ctx.session, Session):
raise err(403, "tool_context_required", "Use an authenticated AI connection.")
session = ctx.session
if perm_scope.ai_apps_refusal(session.user, session.runtime):
raise err(403, "ai_apps_off", "Your account does not have AI apps access.")
session.require("automation")
if write:
from routes_external import _assert_write_scope
_assert_write_scope(session, "automations")
if not session.runtime.available():
raise err(503, "store_unavailable", "The tenant store is unavailable. Nothing was saved.")
return session
def _databases(value):
if isinstance(value, dict):
for key, child in value.items():
if key in {"database", "sourceDatabase", "targetTable", "table", "tableKey"} and child:
if not isinstance(child, str):
raise ValueError("Name each automation database with its key.")
yield child
yield from _databases(child)
elif isinstance(value, list):
for child in value:
yield from _databases(child)
def _scope(ctx, definition):
from routes_external import _assert_database_scope
inputs = {key: definition.get(key) for key in ("config", "trigger", "flow")}
for database in sorted(set(_databases(inputs))):
_assert_database_scope(ctx.session, database)
ctx.describe_database(database)
def _item(definition):
# Configuration and run payloads can contain credentials or row values.
return {key: copy.deepcopy(definition.get(key))
for key in ("id", "name", "kind", "trigger", "schedule", "createdBy", "created")}
def _owned(ctx, args, action):
session = _context(ctx, write=True)
aid = args["id"]
if aid.startswith(("field:", "system:")):
raise err(409, "system_agent", "Change this system automation through its own settings.")
definition = engine.all_definitions(session.runtime).get(aid)
if not definition:
raise err(404, "unknown_automation", "There is no automation with that ID.")
if definition.get("createdBy") != session.uname:
raise err(403, "automation_not_owned", f"You cannot {action} another user's automation.")
if definition.get("system"):
raise err(409, "system_agent", engine.system_agent_refusal(definition["system"]))
_scope(ctx, definition)
return definition
def _sync(session, definition):
# Preview writers must never reconcile the external scheduler.
if not external_activity._preview(session):
from routes_automation import _sync_schedule_or_503
_sync_schedule_or_503(session.tenant, definition)
def create(ctx, args):
"""Preview a once or recurring Automation, then call confirm_change after the user agrees."""
session = _context(ctx, write=True)
# Validate normalized references too, including engine defaults and generated flow steps.
clean, error = engine.clean_definition(args, username=session.uname, rt=session.runtime)
if error:
raise err(400, "invalid_automation", error)
_scope(ctx, clean)
notes = []
definition, error = engine.create(session.runtime, args, username=session.uname, notes=notes)
if error:
raise err(400, "invalid_automation", error)
engine.ensure_agent_contract(session.runtime, definition["id"], session.uname, definition["name"])
_sync(session, definition)
return {**_item(definition), "warnings": notes}
def list_automations(ctx, args):
"""List your Automations within this connection's current database access."""
session = _context(ctx)
items = []
for definition in engine.all_definitions(session.runtime).values():
if definition.get("createdBy") != session.uname or definition.get("system"):
continue
try:
_scope(ctx, definition)
except HTTPException as exc:
if exc.status_code not in (403, 404):
raise
continue
items.append(_item(definition))
return sorted(items, key=lambda row: (row["name"].lower(), row["id"]))
def _paused(ctx, args, paused):
definition = _owned(ctx, args, "pause" if paused else "resume")
session = ctx.session
trigger = definition.get("trigger") or {}
if trigger.get("key") == "once":
body = {"trigger": {**trigger, "paused": paused, "enabled": not paused}}
else:
body = {"schedule": {**definition["schedule"], "enabled": not paused}}
from routes_automation import _agent_owned_guard
_agent_owned_guard(session, definition["id"], body)
updated, error = engine.patch(session.runtime, definition["id"], body, username=session.uname)
if error:
raise err(400, "invalid_automation", error)
engine.ensure_agent_contract(session.runtime, updated["id"], session.uname, updated["name"])
_sync(session, updated)
return _item(updated)
def pause(ctx, args):
"""Preview pausing your Automation, then call confirm_change."""
return _paused(ctx, args, True)
def resume(ctx, args):
"""Preview resuming your Automation, then call confirm_change."""
return _paused(ctx, args, False)
def delete(ctx, args):
"""Preview deleting your Automation, then confirm with the exact phrase shown."""
definition = _owned(ctx, args, "delete")
session = ctx.session
if engine.running(session.tenant, definition["id"]):
raise err(409, "automation_running", "It is running. Wait for it to finish.")
from routes_automation import _agent_marks, _agent_owned_guard, _prune_marks
_agent_owned_guard(session, definition["id"], {})
marked = bool(_agent_marks(session.runtime).get(definition["id"]))
engine.remove(session.runtime, definition["id"])
if marked:
_prune_marks(session, definition["id"])
if not external_activity._preview(session):
import automation_control
try:
automation_control.delete_definition(session.tenant, definition["id"])
except automation_control.ControlPlaneError as exc:
raise err(503, "automation_control_unavailable",
f"The automation was deleted, but its schedules could not be removed: {exc}")
return _item(definition)
def _action(handler, properties=None, required=(), *, read=True, destructive=False):
return {"read": read, "destructive": destructive, "confirm": not read,
"grants": ("automation",), "handler": handler,
"schema": {"type": "object", "description": handler.__doc__,
"properties": properties or {}, "required": list(required), "additionalProperties": False}}
_TEXT = {"type": "string", "minLength": 1}
_ID = {"id": _TEXT}
GROUP = {
"name": "automations", "title": "Automations",
"guide": "Offer to create a reminder or recurring run with automations.create. "
"Use the Automation builder definition: name, optional kind and config, trigger, schedule and flow.actions. "
"For once, use trigger={key:'once', at:'<local ISO date and time>', timezone:'<IANA zone>'}. "
"The time must be in the future. For weekly, use trigger={key:'schedule'} and "
"schedule={cron:'0 8 * * 1', enabled:true}. Recurring cron uses UTC. "
"Use supported action kinds and config shapes in flow.actions. "
"This group cannot configure a Slack destination or test a Slack delivery. "
"An event-driven Automation can send a status reply only through its separately authorized Slack channel agent. "
"That status reply is not a conditional SKU alert or a direct message action. "
"Do not promise delivery until the channel authorization and delivery receipt have been observed. "
"Create, pause, resume and delete need confirm_change. Delete needs the exact phrase shown. "
"List returns only your accessible Automations. You can only change your own Automations. "
"A fired once Automation leaves the list. Its activity and inbox result stay. "
"Use schedules for saved-query schedules. "
'Under MCP rule 9, ask "Do you want me to build a one-time reminder or recurring automation in Loopable?".',
"actions": {
"create": _action(create, {"name": _TEXT, "kind": _TEXT, "config": {"type": "object"},
"trigger": {"type": "object", "properties": {
"key": {"enum": ["once", "schedule"]}, "at": _TEXT, "timezone": _TEXT,
"enabled": {"type": "boolean"}, "paused": {"type": "boolean"}},
"required": ["key"], "additionalProperties": False},
"schedule": {"type": "object", "properties": {
"cron": _TEXT, "enabled": {"type": "boolean"}}, "additionalProperties": False},
"flow": {"type": "object", "properties": {"actions": {"type": "array", "items": {"type": "object"}}},
"required": ["actions"], "additionalProperties": False}}, ("name", "trigger"), read=False),
"list": _action(list_automations),
"pause": _action(pause, _ID, ("id",), read=False),
"resume": _action(resume, _ID, ("id",), read=False),
"delete": _action(delete, _ID, ("id",), read=False, destructive=True),
},
}