Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

feat(tasks): create small products' tasks from task profiles (#127905)

Charles Viene4ab303ee673
diff --git a/products/account_audits/backend/apps.py b/products/account_audits/backend/apps.py
index 6528662209b2..6d4f33bfeeb3 100644
--- a/products/account_audits/backend/apps.py
+++ b/products/account_audits/backend/apps.py
@@ -1,7 +1,12 @@
from django.apps import AppConfig
+from . import task_profiles
+
class AccountAuditsConfig(AppConfig):
default_auto_field = "django.db.models.BigAutoField"
name = "products.account_audits.backend"
label = "account_audits"
+
+ def ready(self) -> None:
+ task_profiles.register()
diff --git a/products/account_audits/backend/logic/execution.py b/products/account_audits/backend/logic/execution.py
index 2def9c4ab7d4..603084ae6385 100644
--- a/products/account_audits/backend/logic/execution.py
+++ b/products/account_audits/backend/logic/execution.py
@@ -13,11 +13,13 @@ from posthog.ph_client import ph_scoped_capture
from posthog.utils import absolute_uri, get_instance_region
from products.account_audits.backend.models import AccountAuditAdmission
+from products.account_audits.backend.task_profiles import ACCOUNT_AUDIT, ACCOUNT_AUDIT_MCP_SCOPES
from products.notebooks.backend.facade import api as notebooks_facade
from products.notebooks.backend.facade.content import convert_notebook_content_to_markdown
from products.skills.backend.facade.api import SkillPrompt
from products.tasks.backend.facade import api as tasks_facade
from products.tasks.backend.facade.billing import get_task_run_cost
+from products.tasks.backend.facade.profiles import TaskRunOptions
logger = logging.getLogger(__name__)
COMPLETION_GRACE = timedelta(minutes=3)
@@ -29,12 +31,13 @@ class AccountAuditOutput(BaseModel):
def create_audit_task(*, team_id: int, user_id: int, skill: SkillPrompt, notebook_short_id: str) -> UUID:
# The sandbox policy admits platform services; audit skills need no other network access.
+ network = ACCOUNT_AUDIT.network
environment_id = tasks_facade.upsert_internal_sandbox_env(
team_id,
"ACCOUNT_AUDIT",
- tasks_facade.SandboxNetworkAccessLevel.CUSTOM,
- allowed_domains=[],
- include_default_domains=False,
+ tasks_facade.SandboxNetworkAccessLevel(network.levels[0]),
+ allowed_domains=list(network.allowed_domains),
+ include_default_domains=network.include_default_domains,
)
created = tasks_facade.create_and_run_task(
team=Team.objects.get(id=team_id),
@@ -45,15 +48,15 @@ def create_audit_task(*, team_id: int, user_id: int, skill: SkillPrompt, noteboo
"with PostHog MCP, even if the skill asks you to create a notebook. "
"Read the saved notebook before you return its short ID as notebook_short_id."
),
- origin_product=tasks_facade.TaskOriginProduct.ACCOUNT_AUDIT,
+ profile=ACCOUNT_AUDIT,
user_id=user_id,
- repository=None,
+ options=TaskRunOptions(
+ mcp_scopes=ACCOUNT_AUDIT_MCP_SCOPES,
+ model="claude-sonnet-5",
+ output_schema=AccountAuditOutput.model_json_schema(),
+ ),
create_pr=False,
- internal=True,
sandbox_environment_id=str(environment_id),
- posthog_mcp_scopes=["user:read", "query:read", "insight:read", "notebook:read", "notebook:write"],
- model="claude-sonnet-5",
- output_schema=AccountAuditOutput,
sandbox_timeout_seconds=3 * 60 * 60,
extra_run_state={"audit_skill_version": skill.version},
)
diff --git a/products/account_audits/backend/task_profiles.py b/products/account_audits/backend/task_profiles.py
new file mode 100644
index 000000000000..d78bf12af0dc
--- /dev/null
+++ b/products/account_audits/backend/task_profiles.py
@@ -0,0 +1,60 @@
+from products.tasks.backend.facade.profiles import (
+ DrivePolicy,
+ GithubAccess,
+ GithubResolution,
+ NetworkAccess,
+ NetworkPolicy,
+ OAuthApp,
+ PrAuthorship,
+ Read,
+ TaskProfile,
+ register_task_profiles,
+)
+
+ACCOUNT_AUDIT_MCP_SCOPES = ["user:read", "query:read", "insight:read", "notebook:read", "notebook:write"]
+
+ACCOUNT_AUDIT = TaskProfile(
+ key="account_audit",
+ origin_product="account_audit",
+ public=False,
+ public_options=frozenset(),
+ source_kind=None,
+ listed=False,
+ read_without_channel=Read.CREATOR,
+ api_visible=False,
+ drive=DrivePolicy.OWNER,
+ max_live_per_user=None,
+ warm=None,
+ runtimes=("acp",),
+ sandbox_templates=("default_base",),
+ network=NetworkPolicy(levels=(NetworkAccess.CUSTOM,)),
+ inherit_user_defaults=False,
+ personal_mcp=False,
+ mcp_agent=None,
+ mcp_scopes=ACCOUNT_AUDIT_MCP_SCOPES,
+ mcp_store_servers=True,
+ mcp_exclude_tools=(),
+ oauth_app=OAuthApp.ARRAY,
+ github_resolution=GithubResolution.NEVER,
+ github_access=GithubAccess.NONE,
+ user_authorable_prs=False,
+ default_pr_authorship=PrAuthorship.BOT,
+ create_pr=False,
+ finish_tool=False,
+ done_on_turn_close=False,
+ idle_minutes=30,
+ inactivity_minutes=10,
+ tool_call_minutes=None,
+ max_wake_minutes=180,
+ billing_product="account_audit",
+ bills_compute=False,
+ max_cost_usd=None,
+ task_budget_usd=None,
+ finish_in_flight=True,
+)
+
+PROFILES = (ACCOUNT_AUDIT,)
+
+
+def register() -> None:
+ register_task_profiles(PROFILES)
diff --git a/products/account_audits/backend/tests/test_account_audits.py b/products/account_audits/backend/tests/test_account_audits.py
index 59670ee6d4f0..dc5f13f83362 100644
--- a/products/account_audits/backend/tests/test_account_audits.py
+++ b/products/account_audits/backend/tests/test_account_audits.py
@@ -130,6 +130,7 @@ class TestAccountAuditStartAPI(APIBaseTest):
self.assertEqual(run.task.created_by_id, self.user.id)
self.assertTrue(run.task.internal)
self.assertEqual(run.task.origin_product, "account_audit")
+ self.assertEqual(run.task.profile, "account_audit")
self.assertIsNone(run.task.repository)
self.assertIn(self.skill.body, run.task.description)
self.assertIn(admission.notebook_short_id, run.task.description)
diff --git a/products/autoresearch/backend/apps.py b/products/autoresearch/backend/apps.py
index 4361a5a1b58f..ad464790da5f 100644
--- a/products/autoresearch/backend/apps.py
+++ b/products/autoresearch/backend/apps.py
@@ -14,3 +14,7 @@ class AutoresearchConfig(AppConfig):
# Lazy "app_label.Model" sender keeps the tasks model off autoresearch's import path.
post_save.connect(on_task_run_saved, sender="tasks.TaskRun", dispatch_uid="autoresearch.on_task_run_saved")
+
+ from products.autoresearch.backend import task_profiles # noqa: PLC0415
+
+ task_profiles.register()
diff --git a/products/autoresearch/backend/task_profiles.py b/products/autoresearch/backend/task_profiles.py
new file mode 100644
index 000000000000..1b0442db451f
--- /dev/null
+++ b/products/autoresearch/backend/task_profiles.py
@@ -0,0 +1,69 @@
+from products.tasks.backend.facade.profiles import (
+ DrivePolicy,
+ GithubAccess,
+ GithubResolution,
+ NetworkAccess,
+ NetworkPolicy,
+ OAuthApp,
+ PrAuthorship,
+ Read,
+ TaskProfile,
+ register_task_profiles,
+)
+
+# The agent explores with execute-sql (query:read, insight:read) and writes only through
+# the autoresearch tools. The PostHog MCP server reads /api/users/@me/ to start a session,
+# so without user:read it refuses the connection and the agent gets none of those tools.
+# The brief carries user-authored text, so the token grants nothing beyond that.
+TRAINING_MCP_SCOPES = ["query:read", "insight:read", "user:read", "autoresearch:read", "autoresearch:write"]
+
+# Added only when the report notebook flag is on for the user who starts the run.
+# notebook:write also exposes notebooks-partial-update and notebooks-destroy, so the brief
+# limits the agent to the notebook it creates in this run.
+REPORT_NOTEBOOK_MCP_SCOPES = ["notebook:read", "notebook:write"]
+
+TRAINING = TaskProfile(
+ key="autoresearch.training",
+ origin_product="autoresearch",
+ public=False,
+ public_options=frozenset(),
+ source_kind=None,
+ listed=False,
+ read_without_channel=Read.CREATOR,
+ api_visible=True,
+ drive=DrivePolicy.OWNER,
+ max_live_per_user=None,
+ warm=None,
+ runtimes=("acp",),
+ sandbox_templates=("default_base", "autoresearch_base"),
+ network=NetworkPolicy(levels=(NetworkAccess.FULL,)),
+ inherit_user_defaults=False,
+ personal_mcp=False,
+ mcp_agent=None,
+ mcp_scopes=[*TRAINING_MCP_SCOPES, *REPORT_NOTEBOOK_MCP_SCOPES],
+ mcp_store_servers=False,
+ mcp_exclude_tools=(),
+ oauth_app=OAuthApp.ARRAY,
+ github_resolution=GithubResolution.WITH_REPOSITORY,
+ github_access=GithubAccess.WRITE,
+ user_authorable_prs=False,
+ default_pr_authorship=PrAuthorship.BOT,
+ create_pr=True,
+ finish_tool=False,
+ done_on_turn_close=False,
+ idle_minutes=30,
+ inactivity_minutes=10,
+ tool_call_minutes=None,
+ max_wake_minutes=180,
+ billing_product="background_agents",
+ bills_compute=False,
+ max_cost_usd=None,
+ task_budget_usd=None,
+ finish_in_flight=True,
+)
+
+PROFILES = (TRAINING,)
+
+
+def register() -> None:
+ register_task_profiles(PROFILES)
diff --git a/products/autoresearch/backend/training/runner.py b/products/autoresearch/backend/training/runner.py
index 91fb420af0c0..325dd0126434 100644
--- a/products/autoresearch/backend/training/runner.py
+++ b/products/autoresearch/backend/training/runner.py
@@ -49,6 +49,7 @@ from products.autoresearch.backend.models import (
AutoresearchTrainingRun,
)
from products.autoresearch.backend.query import INTERACTIVE_QUERY_TIME_LIMIT_S
+from products.autoresearch.backend.task_profiles import REPORT_NOTEBOOK_MCP_SCOPES, TRAINING, TRAINING_MCP_SCOPES
from products.autoresearch.backend.training.agent_model import agent_run_config_for
from products.autoresearch.backend.training.artifacts import MAX_ARTIFACT_BYTES
from products.autoresearch.backend.training.explanation import MAX_TOP_FEATURES
@@ -62,6 +63,7 @@ from products.tasks.backend.facade import (
api as tasks_facade,
cancellation as tasks_cancellation,
)
+from products.tasks.backend.facade.profiles import TaskRunOptions
from products.tasks.backend.facade.sandbox import SandboxTemplate
logger = structlog.get_logger(__name__)
@@ -87,17 +89,6 @@ MAX_SUGGESTION_PROMPT_CHARS = 1500
# agent's context before research begins. The oldest TRY_NEXT suggestions go first.
MAX_PENDING_SUGGESTIONS = 10
-# The agent explores with execute-sql (query:read, insight:read) and writes only through
-# the autoresearch tools. The PostHog MCP server reads /api/users/@me/ to start a session,
-# so without user:read it refuses the connection and the agent gets none of those tools.
-# The brief carries user-authored text, so the token grants nothing beyond that.
-TRAINING_MCP_SCOPES = ["query:read", "insight:read", "user:read", "autoresearch:read", "autoresearch:write"]
-
-# Added only when the report notebook flag is on for the user who starts the run.
-# notebook:write also exposes notebooks-partial-update and notebooks-destroy, so the brief
-# limits the agent to the notebook it creates in this run.
-REPORT_NOTEBOOK_MCP_SCOPES = ["notebook:read", "notebook:write"]
-
# Task.title is a 255-character column, and a pipeline name and target event can each
# take all of it.
_TASK_TITLE_MAX_CHARS = 255
@@ -1037,18 +1028,18 @@ def run_training(
team=pipeline.team,
title=title[:_TASK_TITLE_MAX_CHARS],
description=description,
- origin_product=tasks_facade.TaskOriginProduct.AUTORESEARCH,
+ profile=TRAINING,
user_id=user_id,
- repository=None,
- create_pr=False,
- mode="background",
- internal=True,
# Internal tasks skip team and user run preferences, so without these the run would
# take whatever the Tasks default is.
- runtime_adapter=agent_config.runtime_adapter,
- model=agent_config.model,
- reasoning_effort=agent_config.reasoning_effort,
- posthog_mcp_scopes=mcp_scopes,
+ options=TaskRunOptions(
+ adapter=agent_config.runtime_adapter,
+ model=agent_config.model,
+ reasoning_effort=agent_config.reasoning_effort,
+ mcp_scopes=mcp_scopes,
+ ),
+ create_pr=False,
+ mode="background",
# The autoresearch image is the agent-capable base plus pandas/numpy/
# scikit-learn/pyarrow at system site. The base image lacks the ML libs; the
# notebook image has the libs but cannot host the agent server — only this
diff --git a/products/autoresearch/backend/training/test_training.py b/products/autoresearch/backend/training/test_training.py
index 373e1f87aec3..4e97fba7cb42 100644
--- a/products/autoresearch/backend/training/test_training.py
+++ b/products/autoresearch/backend/training/test_training.py
@@ -23,19 +23,14 @@ from products.autoresearch.backend.models import (
AutoresearchSuggestion,
AutoresearchTrainingRun,
)
+from products.autoresearch.backend.task_profiles import REPORT_NOTEBOOK_MCP_SCOPES, TRAINING, TRAINING_MCP_SCOPES
from products.autoresearch.backend.testing import TeamScopedTestMixin
from products.autoresearch.backend.training.realized_context import (
REALIZED_DATES_PER_MODEL,
RELATED_PIPELINES_LIMIT,
build_realized_context,
)
-from products.autoresearch.backend.training.runner import (
- REPORT_NOTEBOOK_MCP_SCOPES,
- TRAINING_MCP_SCOPES,
- UNTRUSTED_DATA_TAG,
- build_agent_description,
- run_training,
-)
+from products.autoresearch.backend.training.runner import UNTRUSTED_DATA_TAG, build_agent_description, run_training
_UNSCORABLE = UnscorableChampion(failure_kind="limit_exceeded", onset=date(2026, 9, 2))
@@ -372,10 +367,11 @@ class TestRunTraining(TeamScopedTestMixin, BaseTest):
assert flag.call_args.args[0] == self.user
kwargs = facade.create_and_run_task.call_args.kwargs
- assert kwargs["posthog_mcp_scopes"] == expected_scopes
+ assert kwargs["profile"] == TRAINING
+ assert kwargs["options"].mcp_scopes == expected_scopes
assert ("notebooks-create-markdown" in kwargs["description"]) is flag_on
assert "No realized results yet" in kwargs["description"]
- assert "user:read" in kwargs["posthog_mcp_scopes"]
+ assert "user:read" in kwargs["options"].mcp_scopes
assert kwargs["extra_run_state"] == {
"autoresearch_training_run_id": str(training_run.id),
"config_snapshot": {"connectors": {"mcp_installation_ids": []}},
@@ -445,8 +441,8 @@ class TestRunTraining(TeamScopedTestMixin, BaseTest):
training_run = run_training(self.pipeline, iteration_budget=5, user_id=self.user.id)
- kwargs = facade.create_and_run_task.call_args.kwargs
- assert (kwargs["runtime_adapter"], kwargs["model"], kwargs["reasoning_effort"]) == expected
+ options = facade.create_and_run_task.call_args.kwargs["options"]
+ assert (options.adapter, options.model, options.reasoning_effort) == expected
training_run.refresh_from_db()
assert (
training_run.agent_runtime_adapter,
diff --git a/products/business_knowledge/backend/sandbox.py b/products/business_knowledge/backend/sandbox.py
index ae0fa6d54287..ac601995a324 100644
--- a/products/business_knowledge/backend/sandbox.py
+++ b/products/business_knowledge/backend/sandbox.py
@@ -241,10 +241,7 @@ def start_sandbox_run(
mcp_scopes=BK_MCP_SCOPES,
output_schema=SandboxAnswer.model_json_schema(),
),
- extra_run_state={
- "mcp_exclude_tools": list(task_profiles.BUSINESS_KNOWLEDGE.mcp_exclude_tools),
- "config_snapshot": {"connectors": {"mcp_installation_ids": []}},
- },
+ extra_run_state={"config_snapshot": {"connectors": {"mcp_installation_ids": []}}},
)
if created.latest_run is None:
raise RuntimeError("Sandbox task was created without a run")
diff --git a/products/business_knowledge/backend/task_profiles.py b/products/business_knowledge/backend/task_profiles.py
index a2413dd9ef06..5f46466f12d9 100644
--- a/products/business_knowledge/backend/task_profiles.py
+++ b/products/business_knowledge/backend/task_profiles.py
@@ -1,5 +1,4 @@
from products.tasks.backend.facade.profiles import (
- AccessGate,
DrivePolicy,
GithubAccess,
GithubResolution,
@@ -24,7 +23,6 @@ BUSINESS_KNOWLEDGE = TaskProfile(
read_without_channel=Read.CREATOR,
api_visible=False,
drive=DrivePolicy.OWNER,
- access_gate=AccessGate.NONE,
max_live_per_user=MAX_OPEN_RUNS_PER_OWNER,
warm=None,
runtimes=("acp",),
diff --git a/products/business_knowledge/backend/tests/test_playground.py b/products/business_knowledge/backend/tests/test_playground.py
index f92131fc52d2..e89e289857a8 100644
--- a/products/business_knowledge/backend/tests/test_playground.py
+++ b/products/business_knowledge/backend/tests/test_playground.py
@@ -14,6 +14,7 @@ from posthog.models.user import User
from products.business_knowledge.backend.api.playground import BusinessKnowledgePlaygroundChatViewSet
from products.business_knowledge.backend.constants import MAX_OPEN_RUNS_PER_OWNER
from products.business_knowledge.backend.models import PlaygroundChat, PlaygroundTurn
+from products.tasks.backend.facade.temporal import mcp_exclude_tools_for_task
from products.tasks.backend.models import Task, TaskRun
WORKFLOW = "products.tasks.backend.temporal.client.execute_task_processing_workflow"
@@ -167,6 +168,24 @@ class TestPlaygroundChatAPI(APIBaseTest):
assert not Task.objects.filter(origin_product=Task.OriginProduct.BUSINESS_KNOWLEDGE).exists()
assert PlaygroundTurn.objects.unscoped().count() == 0
+ def test_follow_up_keeps_hidden_tools_for_a_task_without_a_profile(self, _ff, _workflow) -> None:
+ chat = self._create_chat()
+ asked = self.client.post(f"{self.url}{chat['id']}/ask/", {"question": "Can I get a refund?"}, format="json")
+ assert asked.status_code == status.HTTP_201_CREATED, asked.content
+ first_turn = asked.json()["turns"][0]
+ Task.objects.filter(id=first_turn["task_id"]).update(profile=None)
+ first_run = TaskRun.objects.get(id=first_turn["run"]["run_id"])
+ first_run.status = TaskRun.Status.COMPLETED
+ first_run.output = {"reply": "Yes, within 30 days.", "sources": []}
+ first_run.state = {**first_run.state, "mcp_exclude_tools": ["project-get", "user-get"]}
+ first_run.save(update_fields=["status", "output", "state"])
+
+ follow_up = self.client.post(f"{self.url}{chat['id']}/ask/", {"question": "And after 30 days?"}, format="json")
+
+ assert follow_up.status_code == status.HTTP_201_CREATED, follow_up.content
+ successor = TaskRun.objects.get(id=follow_up.json()["turns"][1]["run"]["run_id"])
+ assert successor.state["mcp_exclude_tools"] == ["project-get", "user-get"]
+
def test_follow_up_resumes_the_same_sandbox(self, _ff, _workflow) -> None:
chat = self._create_chat()
asked = self.client.post(f"{self.url}{chat['id']}/ask/", {"question": "Can I get a refund?"}, format="json")
@@ -194,7 +213,10 @@ class TestPlaygroundChatAPI(APIBaseTest):
assert successor.task_id == first_run.task_id
assert successor.state["resume_from_run_id"] == str(first_run.id)
assert successor.state["pending_user_message"] == "And after 30 days?"
- assert successor.state["mcp_exclude_tools"] == first_run.state["mcp_exclude_tools"]
+ assert "mcp_exclude_tools" not in successor.state
+ assert mcp_exclude_tools_for_task(successor.task, successor.state) == mcp_exclude_tools_for_task(
+ first_run.task, first_run.state
+ )
assert successor.state["config_snapshot"] == first_run.state["config_snapshot"]
assert successor.state["model"] == first_run.state["model"]
assert successor.state["runtime_adapter"] == first_run.state["runtime_adapter"]
diff --git a/products/business_knowledge/backend/tests/test_sandbox.py b/products/business_knowledge/backend/tests/test_sandbox.py
index e671d4a6b677..13c0aaa37823 100644
--- a/products/business_knowledge/backend/tests/test_sandbox.py
+++ b/products/business_knowledge/backend/tests/test_sandbox.py
@@ -31,6 +31,7 @@ from products.business_knowledge.backend.sandbox import (
format_always_on_context,
parse_sandbox_log,
)
+from products.tasks.backend.facade.temporal import mcp_exclude_tools_for_task
from products.tasks.backend.models import SandboxEnvironment, Task, TaskRun
WORKFLOW = "products.tasks.backend.temporal.client.execute_task_processing_workflow"
@@ -242,6 +243,7 @@ class TestSandboxAPI(APIBaseTest):
"user:read",
"project:read",
]
+ assert "mcp_exclude_tools" not in run.state
assert {
DOCS_SEARCH_TOOL,
"user-get",
@@ -250,7 +252,7 @@ class TestSandboxAPI(APIBaseTest):
"mcp-connection-tools-list",
"tasks-runs-session-logs-retrieve",
"tasks-artifacts-list",
- } <= set(run.state["mcp_exclude_tools"])
+ } <= set(mcp_exclude_tools_for_task(task, run.state))
assert run.state["config_snapshot"]["connectors"]["mcp_installation_ids"] == []
assert run.state["model"] == "claude-sonnet-5"
assert run.state["runtime_adapter"] == "claude"
diff --git a/products/canvas/backend/tests/test_canvas_api.py b/products/canvas/backend/tests/test_canvas_api.py
index 06ef0b537a40..e5f86df23af8 100644
--- a/products/canvas/backend/tests/test_canvas_api.py
+++ b/products/canvas/backend/tests/test_canvas_api.py
@@ -2553,6 +2553,7 @@ class TestCanvasActions(CanvasAPIBaseTest):
task = Task.objects.get(id=response.json()["result"]["task_id"])
assert task.created_by_id == self.user.id
assert task.channel_id == self.channel.id
+ assert task.profile == "user"
assert task.title == "Follow up"
assert not task.runs.exists()
@@ -2640,6 +2641,7 @@ class TestCanvasActions(CanvasAPIBaseTest):
run = task.runs.get(id=response.json()["result"]["run_id"])
assert task.created_by_id == viewer.id
assert task.channel_id == self.channel.id
+ assert task.profile == "user"
assert task.repositories == repositories
assert task.github_integration_id == integration.id
assert run.environment == TaskRun.Environment.CLOUD
diff --git a/products/context_layer/backend/apps.py b/products/context_layer/backend/apps.py
index 17839de74478..9c867847e572 100644
--- a/products/context_layer/backend/apps.py
+++ b/products/context_layer/backend/apps.py
@@ -1,8 +1,13 @@
from django.apps import AppConfig
+from . import task_profiles
+
class ContextLayerAppConfig(AppConfig):
default_auto_field = "django.db.models.BigAutoField"
name = "products.context_layer.backend"
label = "context_layer"
verbose_name = "Context layer"
+
+ def ready(self) -> None:
+ task_profiles.register()
diff --git a/products/context_layer/backend/task_profiles.py b/products/context_layer/backend/task_profiles.py
new file mode 100644
index 000000000000..a95654e6719d
--- /dev/null
+++ b/products/context_layer/backend/task_profiles.py
@@ -0,0 +1,58 @@
+from products.tasks.backend.facade.profiles import (
+ DrivePolicy,
+ GithubAccess,
+ GithubResolution,
+ NetworkAccess,
+ NetworkPolicy,
+ OAuthApp,
+ PrAuthorship,
+ Read,
+ TaskProfile,
+ register_task_profiles,
+)
+
+DREAM = TaskProfile(
+ key="context_layer.dream",
+ origin_product="context_layer",
+ public=False,
+ public_options=frozenset(),
+ source_kind=None,
+ listed=False,
+ read_without_channel=Read.CREATOR,
+ api_visible=True,
+ drive=DrivePolicy.OWNER,
+ max_live_per_user=None,
+ warm=None,
+ runtimes=("acp",),
+ sandbox_templates=("default_base",),
+ network=NetworkPolicy(levels=(NetworkAccess.FULL,)),
+ inherit_user_defaults=False,
+ personal_mcp=False,
+ mcp_agent=None,
+ mcp_scopes="full",
+ mcp_store_servers=True,
+ mcp_exclude_tools=(),
+ oauth_app=OAuthApp.ARRAY,
+ github_resolution=GithubResolution.WITH_REPOSITORY,
+ github_access=GithubAccess.WRITE,
+ user_authorable_prs=False,
+ default_pr_authorship=PrAuthorship.BOT,
+ create_pr=True,
+ finish_tool=False,
+ done_on_turn_close=False,
+ idle_minutes=30,
+ inactivity_minutes=10,
+ tool_call_minutes=None,
+ max_wake_minutes=180,
+ billing_product="background_agents",
+ bills_compute=False,
+ max_cost_usd=None,
+ task_budget_usd=None,
+ finish_in_flight=True,
+)
+
+PROFILES = (DREAM,)
+
+
+def register() -> None:
+ register_task_profiles(PROFILES)
diff --git a/products/context_layer/backend/temporal/dreaming.py b/products/context_layer/backend/temporal/dreaming.py
index fff1aa0bb440..35b78ba69f2d 100644
--- a/products/context_layer/backend/temporal/dreaming.py
+++ b/products/context_layer/backend/temporal/dreaming.py
@@ -37,7 +37,7 @@ from posthog.temporal.oauth import CONTEXT_LAYER_INTERNAL_SCOPE, MCP_READ_SCOPES
from products.context_layer.backend.dreams import DREAM_AI_STAGE
from products.context_layer.backend.facade import api as context_layer_facade
from products.context_layer.backend.models import ContextLayerConfig
-from products.tasks.backend.facade.api import TaskOriginProduct
+from products.context_layer.backend.task_profiles import DREAM
logger = structlog.get_logger(__name__)
@@ -205,9 +205,8 @@ async def dispatch_dream_run(input: DispatchDreamRunInput) -> DispatchDreamRunOu
initial_permission_mode="full-access",
),
step_name="context-layer-dream",
- origin_product=TaskOriginProduct.CONTEXT_LAYER,
+ profile=DREAM,
ai_stage=DREAM_AI_STAGE,
- internal=True,
workflow_id_prefix="context-layer-dream",
)
except Exception:
diff --git a/products/context_layer/backend/test/test_dreaming.py b/products/context_layer/backend/test/test_dreaming.py
index 76e562590fa3..b89c9fbe22dc 100644
--- a/products/context_layer/backend/test/test_dreaming.py
+++ b/products/context_layer/backend/test/test_dreaming.py
@@ -12,6 +12,7 @@ from parameterized import parameterized
from products.context_layer.backend.admin import ContextLayerConfigAdmin
from products.context_layer.backend.models import ContextLayerConfig
+from products.context_layer.backend.task_profiles import DREAM
from products.context_layer.backend.temporal import dreaming
@@ -171,8 +172,7 @@ class TestDreamingLane(BaseTest):
assert context.initial_permission_mode == "full-access"
assert context.posthog_mcp_scopes == [*dreaming.MCP_READ_SCOPES, dreaming.CONTEXT_LAYER_INTERNAL_SCOPE]
assert trigger_mock.call_args.kwargs["ai_stage"] == dreaming.DREAM_AI_STAGE
- assert trigger_mock.call_args.kwargs["origin_product"] == "context_layer"
- assert trigger_mock.call_args.kwargs["internal"] is True
+ assert trigger_mock.call_args.kwargs["profile"] == DREAM
prompt = trigger_mock.call_args.args[0]
assert prompt.startswith(
"This is the first dream: review the last 7 days of organizational activity. Treat this as a seed run:"
diff --git a/products/conversations/backend/apps.py b/products/conversations/backend/apps.py
index 50d2f6139d7c..e30754e67c87 100644
--- a/products/conversations/backend/apps.py
+++ b/products/conversations/backend/apps.py
@@ -12,7 +12,9 @@ class ConversationsConfig(AppConfig):
from . import (
activity_logging, # noqa: F401, PLC0415
signals, # noqa: F401
+ task_profiles,
)
from .learning_provider import register_conversations_learning_provider
register_conversations_learning_provider()
+ task_profiles.register()
diff --git a/products/conversations/backend/task_profiles.py b/products/conversations/backend/task_profiles.py
new file mode 100644
index 000000000000..2c2bf78d7433
--- /dev/null
+++ b/products/conversations/backend/task_profiles.py
@@ -0,0 +1,58 @@
+from products.tasks.backend.facade.profiles import (
+ DrivePolicy,
+ GithubAccess,
+ GithubResolution,
+ NetworkAccess,
+ NetworkPolicy,
+ OAuthApp,
+ PrAuthorship,
+ Read,
+ TaskProfile,
+ register_task_profiles,
+)
+
+SUPPORT_REPLY = TaskProfile(
+ key="conversations.support_reply",
+ origin_product="support_reply",
+ public=False,
+ public_options=frozenset(),
+ source_kind=None,
+ listed=False,
+ read_without_channel=Read.CREATOR,
+ api_visible=True,
+ drive=DrivePolicy.OWNER,
+ max_live_per_user=None,
+ warm=None,
+ runtimes=("acp",),
+ sandbox_templates=("default_base",),
+ network=NetworkPolicy(levels=(NetworkAccess.CUSTOM,)),
+ inherit_user_defaults=False,
+ personal_mcp=False,
+ mcp_agent="support",
+ mcp_scopes="read_only",
+ mcp_store_servers=True,
+ mcp_exclude_tools=(),
+ oauth_app=OAuthApp.ARRAY,
+ github_resolution=GithubResolution.WITH_REPOSITORY,
+ github_access=GithubAccess.WRITE,
+ user_authorable_prs=False,
+ default_pr_authorship=PrAuthorship.BOT,
+ create_pr=True,
+ finish_tool=False,
+ done_on_turn_close=False,
+ idle_minutes=30,
+ inactivity_minutes=10,
+ tool_call_minutes=None,
+ max_wake_minutes=180,
+ billing_product="conversations",
+ bills_compute=False,
+ max_cost_usd=None,
+ task_budget_usd=None,
+ finish_in_flight=True,
+)
+
+PROFILES = (SUPPORT_REPLY,)
+
+
+def register() -> None:
+ register_task_profiles(PROFILES)
diff --git a/products/conversations/backend/temporal/ai_reply/activities/draft.py b/products/conversations/backend/temporal/ai_reply/activities/draft.py
index d313f58200e5..bb7dd8203f5c 100644
--- a/products/conversations/backend/temporal/ai_reply/activities/draft.py
+++ b/products/conversations/backend/temporal/ai_reply/activities/draft.py
@@ -18,6 +18,7 @@ from posthog.temporal.oauth import PosthogMcpScopes
from products.business_knowledge.backend.constants import MAX_ALWAYS_ON_CONTEXT_CHARS
from products.business_knowledge.backend.logic import get_chunks_by_ids
from products.conversations.backend.playbook import compose_support_playbook, is_posthog_docs_source
+from products.conversations.backend.task_profiles import SUPPORT_REPLY
from products.conversations.backend.temporal.ai_reply.constants import (
BASE_DRAFT_SCOPES,
DIAGNOSTIC_SCOPES_PRESET,
@@ -45,7 +46,6 @@ from products.conversations.backend.temporal.helpers import (
get_or_create_support_sandbox_env,
resolve_user_id_for_support,
)
-from products.tasks.backend.facade import api as tasks_facade
from products.tasks.backend.facade.agents import EmptyAgentTurnError, MultiTurnSession
logger = structlog.get_logger(__name__)
@@ -414,9 +414,7 @@ Return your response as a JSON object with keys: reply, citations, confidence (a
prompt,
context,
step_name="support_reply",
- origin_product=tasks_facade.TaskOriginProduct.SUPPORT_REPLY,
- mcp_builtin_agent_key="support",
- internal=True,
+ profile=SUPPORT_REPLY,
max_poll_seconds=DRAFT_POLL_SECONDS,
)
except EmptyAgentTurnError:
diff --git a/products/conversations/backend/temporal/helpers.py b/products/conversations/backend/temporal/helpers.py
index c54a197bb766..fc220cceabe9 100644
--- a/products/conversations/backend/temporal/helpers.py
+++ b/products/conversations/backend/temporal/helpers.py
@@ -5,6 +5,7 @@ import structlog
from posthog.models.organization import OrganizationMembership
from posthog.models.team.team import Team
+from products.conversations.backend.task_profiles import SUPPORT_REPLY
from products.tasks.backend.facade import api as tasks_facade
logger = structlog.get_logger(__name__)
@@ -25,15 +26,16 @@ def get_or_create_support_sandbox_env(team_id: int) -> str:
exfiltration channel that TRUSTED's broad allowlist would otherwise leave open. This agent
only drafts text + calls read-only MCP tools; it has no reason to fetch from the internet.
"""
+ network = SUPPORT_REPLY.network
return str(
tasks_facade.upsert_internal_sandbox_env(
team_id,
CONVERSATIONS_SUPPORT_REPLY_ENV_NAME,
- tasks_facade.SandboxNetworkAccessLevel.CUSTOM,
+ tasks_facade.SandboxNetworkAccessLevel(network.levels[0]),
private=False,
internal=True,
- allowed_domains=[],
- include_default_domains=False,
+ allowed_domains=list(network.allowed_domains),
+ include_default_domains=network.include_default_domains,
)
)
diff --git a/products/experiments/backend/apps.py b/products/experiments/backend/apps.py
index 2810eec9fcd3..74579ec04150 100644
--- a/products/experiments/backend/apps.py
+++ b/products/experiments/backend/apps.py
@@ -69,3 +69,7 @@ class ExperimentsConfig(AppConfig):
register_post_delete_hook("experiment", _post_delete)
register_post_restore_hook("experiment", _post_restore)
+
+ from products.experiments.backend import task_profiles # noqa: PLC0415
+
+ task_profiles.register()
diff --git a/products/experiments/backend/experiment_service.py b/products/experiments/backend/experiment_service.py
index a3d7167ec01e..19e7d10126c7 100644
--- a/products/experiments/backend/experiment_service.py
+++ b/products/experiments/backend/experiment_service.py
@@ -121,6 +121,7 @@ from products.experiments.backend.models.experiment import (
)
from products.experiments.backend.models.team_experiments_config import TeamExperimentsConfig
from products.experiments.backend.result_serialization import strip_step_sessions
+from products.experiments.backend.task_profiles import CLEANUP
from products.experiments.backend.warehouse_access_control import validate_warehouse_metrics
from products.experiments.backend.warehouse_native_sources import (
validate_experiment_warehouse_native_sources,
@@ -2789,7 +2790,7 @@ class ExperimentService:
team=team,
title=title,
description=description,
- origin_product=tasks_facade.TaskOriginProduct.EXPERIMENTS,
+ profile=CLEANUP,
user_id=user_id,
repository=repository,
create_pr=True,
diff --git a/products/experiments/backend/task_profiles.py b/products/experiments/backend/task_profiles.py
new file mode 100644
index 000000000000..5d3f80a6a54e
--- /dev/null
+++ b/products/experiments/backend/task_profiles.py
@@ -0,0 +1,58 @@
+from products.tasks.backend.facade.profiles import (
+ DrivePolicy,
+ GithubAccess,
+ GithubResolution,
+ NetworkAccess,
+ NetworkPolicy,
+ OAuthApp,
+ PrAuthorship,
+ Read,
+ TaskProfile,
+ register_task_profiles,
+)
+
+CLEANUP = TaskProfile(
+ key="experiments.cleanup",
+ origin_product="experiments",
+ public=False,
+ public_options=frozenset(),
+ source_kind=None,
+ listed=True,
+ read_without_channel=Read.TEAM,
+ api_visible=True,
+ drive=DrivePolicy.OWNER,
+ max_live_per_user=None,
+ warm=None,
+ runtimes=("acp",),
+ sandbox_templates=("default_base",),
+ network=NetworkPolicy(levels=(NetworkAccess.FULL,)),
+ inherit_user_defaults=True,
+ personal_mcp=True,
+ mcp_agent=None,
+ mcp_scopes="full",
+ mcp_store_servers=True,
+ mcp_exclude_tools=(),
+ oauth_app=OAuthApp.ARRAY,
+ github_resolution=GithubResolution.WITH_REPOSITORY,
+ github_access=GithubAccess.WRITE,
+ user_authorable_prs=False,
+ default_pr_authorship=PrAuthorship.BOT,
+ create_pr=True,
+ finish_tool=False,
+ done_on_turn_close=False,
+ idle_minutes=30,
+ inactivity_minutes=10,
+ tool_call_minutes=None,
+ max_wake_minutes=180,
+ billing_product="posthog_code",
+ bills_compute=False,
+ max_cost_usd=None,
+ task_budget_usd=None,
+ finish_in_flight=True,
+)
+
+PROFILES = (CLEANUP,)
+
+
+def register() -> None:
+ register_task_profiles(PROFILES)
diff --git a/products/experiments/backend/test/test_experiment_cleanup_pr.py b/products/experiments/backend/test/test_experiment_cleanup_pr.py
index 3e546ebcc66e..bddf20406f2d 100644
--- a/products/experiments/backend/test/test_experiment_cleanup_pr.py
+++ b/products/experiments/backend/test/test_experiment_cleanup_pr.py
@@ -16,8 +16,8 @@ from posthog.models.user_integration import UserIntegration
from products.experiments.backend.experiment_service import ExperimentService
from products.experiments.backend.models.experiment import Experiment
from products.experiments.backend.models.team_experiments_config import TeamExperimentsConfig
+from products.experiments.backend.task_profiles import CLEANUP
from products.feature_flags.backend.models.feature_flag import FeatureFlag
-from products.tasks.backend.facade import api as tasks_facade
class TestExperimentCleanupPr(APIBaseTest):
@@ -90,7 +90,7 @@ class TestExperimentCleanupPr(APIBaseTest):
if expect_task_created:
mock_create_task.assert_called_once()
kwargs = mock_create_task.call_args.kwargs
- self.assertEqual(kwargs["origin_product"], tasks_facade.TaskOriginProduct.EXPERIMENTS)
+ self.assertEqual(kwargs["profile"], CLEANUP)
self.assertEqual(kwargs["repository"], "posthog/posthog")
self.assertTrue(kwargs["create_pr"])
self.assertEqual(experiment.flag_cleanup_task_id, task_id)
diff --git a/products/knowledge_writer/backend/apps.py b/products/knowledge_writer/backend/apps.py
index 3ea77291c56a..1a3db18192d2 100644
--- a/products/knowledge_writer/backend/apps.py
+++ b/products/knowledge_writer/backend/apps.py
@@ -7,6 +7,7 @@ class KnowledgeWriterConfig(AppConfig):
label = "knowledge_writer"
def ready(self) -> None:
- from products.knowledge_writer.backend import receivers # noqa: PLC0415 — needs the app registry
+ from products.knowledge_writer.backend import receivers, task_profiles # noqa: PLC0415 — needs the app registry
receivers.connect()
+ task_profiles.register()
diff --git a/products/knowledge_writer/backend/logic/launch.py b/products/knowledge_writer/backend/logic/launch.py
index 71968c0c2b5b..e6f17c94aadd 100644
--- a/products/knowledge_writer/backend/logic/launch.py
+++ b/products/knowledge_writer/backend/logic/launch.py
@@ -11,6 +11,7 @@ from products.tasks.backend.facade import api as tasks_facade
from ..adapters.registry import REGISTRY
from ..facade.contracts import DocsRequest
from ..settings import WriterSettings
+from ..task_profiles import WRITER
from .caps import WriterRerunTaken, claim_section
from .records import (
JOIN_STATE_KEY,
@@ -123,11 +124,10 @@ def create_writer_task(
team=team,
title=f"Docs: {request.source_url}"[:255],
description=description,
- origin_product=tasks_facade.TaskOriginProduct.KNOWLEDGE_WRITER,
+ profile=WRITER,
user_id=writer.user_id,
repository=writer.docs_repository,
create_pr=False,
- internal=True,
posthog_mcp_scopes=[],
extra_run_state=no_store_connectors_run_state(),
origin_key=request.dedupe_id,
diff --git a/products/knowledge_writer/backend/task_profiles.py b/products/knowledge_writer/backend/task_profiles.py
new file mode 100644
index 000000000000..dff33a45b9c8
--- /dev/null
+++ b/products/knowledge_writer/backend/task_profiles.py
@@ -0,0 +1,58 @@
+from products.tasks.backend.facade.profiles import (
+ DrivePolicy,
+ GithubAccess,
+ GithubResolution,
+ NetworkAccess,
+ NetworkPolicy,
+ OAuthApp,
+ PrAuthorship,
+ Read,
+ TaskProfile,
+ register_task_profiles,
+)
+
+WRITER = TaskProfile(
+ key="knowledge_writer.docs",
+ origin_product="knowledge_writer",
+ public=False,
+ public_options=frozenset(),
+ source_kind=None,
+ listed=False,
+ read_without_channel=Read.CREATOR,
+ api_visible=True,
+ drive=DrivePolicy.OWNER,
+ max_live_per_user=None,
+ warm=None,
+ runtimes=("acp",),
+ sandbox_templates=("default_base",),
+ network=NetworkPolicy(levels=(NetworkAccess.FULL,)),
+ inherit_user_defaults=False,
+ personal_mcp=False,
+ mcp_agent=None,
+ mcp_scopes=[],
+ mcp_store_servers=True,
+ mcp_exclude_tools=(),
+ oauth_app=OAuthApp.ARRAY,
+ github_resolution=GithubResolution.WITH_REPOSITORY,
+ github_access=GithubAccess.WRITE,
+ user_authorable_prs=False,
+ default_pr_authorship=PrAuthorship.BOT,
+ create_pr=True,
+ finish_tool=False,
+ done_on_turn_close=False,
+ idle_minutes=30,
+ inactivity_minutes=10,
+ tool_call_minutes=None,
+ max_wake_minutes=180,
+ billing_product="background_agents",
+ bills_compute=False,
+ max_cost_usd=None,
+ task_budget_usd=None,
+ finish_in_flight=True,
+)
+
+PROFILES = (WRITER,)
+
+
+def register() -> None:
+ register_task_profiles(PROFILES)
diff --git a/products/knowledge_writer/backend/tests/test_intake.py b/products/knowledge_writer/backend/tests/test_intake.py
index a913f292977f..4ea3c3a7d6c7 100644
--- a/products/knowledge_writer/backend/tests/test_intake.py
+++ b/products/knowledge_writer/backend/tests/test_intake.py
@@ -35,6 +35,7 @@ from products.knowledge_writer.backend.logic.records import (
)
from products.knowledge_writer.backend.logic.routing import docs_section
from products.knowledge_writer.backend.settings import writer_settings
+from products.knowledge_writer.backend.task_profiles import WRITER
from products.tasks.backend.facade import api as tasks_facade
from products.tasks.backend.models import Task, TaskRun
@@ -212,6 +213,7 @@ def test_a_request_starts_one_internal_writer_task_and_a_repeat_is_a_duplicate(t
task = tasks_facade.get_task_by_origin_key(team.id, verdict.request.dedupe_id)
assert task is not None
assert task.origin_product == tasks_facade.TaskOriginProduct.KNOWLEDGE_WRITER
+ assert Task.objects.get(id=task.id).profile == WRITER.key
assert task.repository == "posthog/posthog.com"
stored_request = tasks_facade.read_task_state_entry(task.id, team.id, REQUEST_STATE_KEY)
assert isinstance(stored_request, dict)
diff --git a/products/metrics/backend/apps.py b/products/metrics/backend/apps.py
index 276f8aa58256..955696f9573b 100644
--- a/products/metrics/backend/apps.py
+++ b/products/metrics/backend/apps.py
@@ -18,3 +18,7 @@ class MetricsConfig(AppConfig):
from products.metrics.backend.alerts.registration import register # noqa: PLC0415
register()
+
+ from products.metrics.backend import task_profiles # noqa: PLC0415
+
+ task_profiles.register()
diff --git a/products/metrics/backend/dashboard_import/importer.py b/products/metrics/backend/dashboard_import/importer.py
index b65c0e1b7256..34941ed9e320 100644
--- a/products/metrics/backend/dashboard_import/importer.py
+++ b/products/metrics/backend/dashboard_import/importer.py
@@ -109,8 +109,15 @@ from products.metrics.backend.facade.enums import (
PanelImportOutcome,
PanelProgressState,
)
+from products.metrics.backend.task_profiles import (
+ AGENT_HIDDEN_TOOLS,
+ AGENT_MCP_SCOPES,
+ DASHBOARD_IMPORT,
+ MAX_RUNNING_IMPORTS,
+)
from products.tasks.backend.facade import api as tasks_facade
from products.tasks.backend.facade.contracts import TaskRunDTO, TaskRunInputFile
+from products.tasks.backend.facade.profiles import TaskRunOptions
logger = structlog.get_logger(__name__)
@@ -118,37 +125,6 @@ IMPORT_STATE_KEY = "metrics_dashboard_import"
SANDBOX_ENVIRONMENT_NAME = "METRICS_DASHBOARD_IMPORT"
AGENT_MODEL = "claude-sonnet-5"
AGENT_RUNTIME_ADAPTER = "claude"
-# The PostHog MCP server reads the user and the project to start a session, so it needs user:read and
-# project:read. The rest lets the agent read metrics, logs and traces. Nothing lets it write.
-AGENT_MCP_SCOPES = ["metrics:read", "logs:read", "tracing:read", "user:read", "project:read"]
-# Read tools that the internal scopes unlock but the conversion never needs. The input can carry planted
-# instructions, so hide every tool that reads other data of the user.
-AGENT_HIDDEN_TOOLS = [
- "docs-search",
- "user-get",
- "user-home-settings-get",
- "llma-personal-spend",
- "reminder-get",
- "reminders-list",
- "mcp-connections-list",
- "mcp-connection-tools-list",
- "tasks-list",
- "tasks-retrieve",
- "tasks-runs-list",
- "tasks-runs-retrieve",
- "tasks-runs-session-logs-retrieve",
- "tasks-artifacts-list",
- "tasks-config-list",
- "tasks-me-config-list",
- "tasks-models-retrieve",
- "channel-list",
- "channel-retrieve",
- "channel-instructions-retrieve",
- "inbox-reports-list",
- "inbox-reports-retrieve",
- "task-context-wiki-channel-resolve",
- "task-context-wiki-page-retrieve",
-]
START_CHECK_SECONDS = 20.0
FINAL_CHECK_SECONDS = 60.0
# A finalizer that holds the claim longer than this died before it saved a result, so another may take over.
@@ -163,7 +139,6 @@ STORAGE_TTL_DAYS = "30"
DEFAULT_SCREENSHOT_LAYOUT = GridLayout(x=0, y=0, w=6, h=4)
_QUERY_KINDS = frozenset({"timeseries", "stat", "gauge", "bargauge", "table", "heatmap"})
_AGENT_FAILED_MESSAGE = "The import agent stopped before it finished. Try again."
-MAX_RUNNING_IMPORTS = 3
RECENT_IMPORTS_WINDOW = dt.timedelta(days=7)
MAX_RECENT_IMPORTS = 20
MAX_LAYOUT_ROUNDS = 3
@@ -566,29 +541,30 @@ class DashboardImporter:
with transaction.atomic():
self._admit()
+ network = DASHBOARD_IMPORT.network
environment_id = tasks_facade.upsert_internal_sandbox_env(
self._team.id,
SANDBOX_ENVIRONMENT_NAME,
- tasks_facade.SandboxNetworkAccessLevel.CUSTOM,
+ tasks_facade.SandboxNetworkAccessLevel(network.levels[0]),
private=False,
internal=True,
- allowed_domains=[],
- include_default_domains=False,
+ allowed_domains=list(network.allowed_domains),
+ include_default_domains=network.include_default_domains,
)
created = tasks_facade.create_and_run_task(
team=self._team,
title=f"Import dashboard: {state.dashboard_name}"[:255],
description=prompt,
- origin_product=tasks_facade.TaskOriginProduct.METRICS_IMPORT,
+ profile=DASHBOARD_IMPORT,
user_id=self._user.id,
- repository=None,
+ options=TaskRunOptions(
+ adapter=AGENT_RUNTIME_ADAPTER,
+ model=AGENT_MODEL,
+ mcp_scopes=AGENT_MCP_SCOPES,
+ output_schema=AgentImportOutput.model_json_schema(),
+ ),
create_pr=False,
- internal=True,
sandbox_environment_id=str(environment_id),
- posthog_mcp_scopes=AGENT_MCP_SCOPES,
- model=AGENT_MODEL,
- runtime_adapter=AGENT_RUNTIME_ADAPTER,
- output_schema=AgentImportOutput,
extra_run_state={
"mcp_exclude_tools": AGENT_HIDDEN_TOOLS,
"config_snapshot": {"connectors": {"mcp_installation_ids": []}},
diff --git a/products/metrics/backend/task_profiles.py b/products/metrics/backend/task_profiles.py
new file mode 100644
index 000000000000..84aab0d78574
--- /dev/null
+++ b/products/metrics/backend/task_profiles.py
@@ -0,0 +1,91 @@
+from products.tasks.backend.facade.profiles import (
+ DrivePolicy,
+ GithubAccess,
+ GithubResolution,
+ NetworkAccess,
+ NetworkPolicy,
+ OAuthApp,
+ PrAuthorship,
+ Read,
+ TaskProfile,
+ register_task_profiles,
+)
+
+# The PostHog MCP server reads the user and the project to start a session, so it needs user:read and
+# project:read. The rest lets the agent read metrics, logs and traces. Nothing lets it write.
+AGENT_MCP_SCOPES = ["metrics:read", "logs:read", "tracing:read", "user:read", "project:read"]
+# Read tools that the internal scopes unlock but the conversion never needs. The input can carry planted
+# instructions, so hide every tool that reads other data of the user.
+AGENT_HIDDEN_TOOLS = [
+ "docs-search",
+ "user-get",
+ "user-home-settings-get",
+ "llma-personal-spend",
+ "reminder-get",
+ "reminders-list",
+ "mcp-connections-list",
+ "mcp-connection-tools-list",
+ "tasks-list",
+ "tasks-retrieve",
+ "tasks-runs-list",
+ "tasks-runs-retrieve",
+ "tasks-runs-session-logs-retrieve",
+ "tasks-artifacts-list",
+ "tasks-config-list",
+ "tasks-me-config-list",
+ "tasks-models-retrieve",
+ "channel-list",
+ "channel-retrieve",
+ "channel-instructions-retrieve",
+ "inbox-reports-list",
+ "inbox-reports-retrieve",
+ "task-context-wiki-channel-resolve",
+ "task-context-wiki-page-retrieve",
+]
+MAX_RUNNING_IMPORTS = 3
+
+DASHBOARD_IMPORT = TaskProfile(
+ key="metrics.dashboard_import",
+ origin_product="metrics_import",
+ public=False,
+ public_options=frozenset(),
+ source_kind=None,
+ listed=False,
+ read_without_channel=Read.CREATOR,
+ api_visible=False,
+ drive=DrivePolicy.OWNER,
+ max_live_per_user=MAX_RUNNING_IMPORTS,
+ warm=None,
+ runtimes=("acp",),
+ sandbox_templates=("default_base",),
+ network=NetworkPolicy(levels=(NetworkAccess.CUSTOM,)),
+ inherit_user_defaults=False,
+ personal_mcp=False,
+ mcp_agent=None,
+ mcp_scopes=AGENT_MCP_SCOPES,
+ mcp_store_servers=False,
+ mcp_exclude_tools=tuple(AGENT_HIDDEN_TOOLS),
+ oauth_app=OAuthApp.POSTHOG_AI,
+ github_resolution=GithubResolution.WITH_REPOSITORY,
+ github_access=GithubAccess.WRITE,
+ user_authorable_prs=False,
+ default_pr_authorship=PrAuthorship.BOT,
+ create_pr=False,
+ finish_tool=False,
+ done_on_turn_close=False,
+ idle_minutes=30,
+ inactivity_minutes=10,
+ tool_call_minutes=None,
+ max_wake_minutes=180,
+ billing_product="posthog_ai",
+ bills_compute=False,
+ max_cost_usd=None,
+ task_budget_usd=None,
+ finish_in_flight=True,
+)
+
+PROFILES = (DASHBOARD_IMPORT,)
+
+
+def register() -> None:
+ register_task_profiles(PROFILES)
diff --git a/products/metrics/backend/tests/test_dashboard_import_api.py b/products/metrics/backend/tests/test_dashboard_import_api.py
index f26bb21abcdb..b16dcf4c1b03 100644
--- a/products/metrics/backend/tests/test_dashboard_import_api.py
+++ b/products/metrics/backend/tests/test_dashboard_import_api.py
@@ -172,6 +172,7 @@ class TestDashboardImportAPI(APIBaseTest):
task = Task.objects.get(id=body["id"])
run = TaskRun.objects.get(task=task)
assert (task.origin_product, task.internal, task.repository) == (Task.OriginProduct.METRICS_IMPORT, True, None)
+ assert task.profile == "metrics.dashboard_import"
assert run.state["pending_dispatch"]["posthog_mcp_scopes"] == AGENT_MCP_SCOPES
assert "docs-search" in run.state["mcp_exclude_tools"]
assert {artifact["name"] for artifact in run.artifacts} == {"brief.json", "grafana-dashboard.json"}
diff --git a/products/tasks/backend/apps.py b/products/tasks/backend/apps.py
index 244b0e9aa986..25a0a3b07fec 100644
--- a/products/tasks/backend/apps.py
+++ b/products/tasks/backend/apps.py
@@ -10,4 +10,6 @@ class TasksConfig(AppConfig):
# Signal receivers live in their own import-light modules so every
# process type (celery, temporal, migrate) wires them without pulling
# the viewset import graph into django.setup().
- from products.tasks.backend import search_index, team_deletion # noqa: F401, PLC0415
+ from products.tasks.backend import search_index, task_profiles, team_deletion # noqa: F401, PLC0415
+
+ task_profiles.register()
diff --git a/products/tasks/backend/facade/api.py b/products/tasks/backend/facade/api.py
index 5e087c1626ef..9542b384bcb5 100644
--- a/products/tasks/backend/facade/api.py
+++ b/products/tasks/backend/facade/api.py
@@ -214,6 +214,7 @@ from products.tasks.backend.repository_config_analytics import (
capture_space_context_changed,
repositories_differ,
)
+from products.tasks.backend.task_profiles import SPACE_SETUP, USER, WIZARD
from products.tasks.backend.task_sources import apply_task_source, idempotency_key_q, source_q
from products.tasks.backend.visibility import (
PRODUCT_PRIVATE_ORIGIN_PRODUCTS,
@@ -2287,17 +2288,17 @@ def create_wizard_cloud_run(
team=team,
title="Set up PostHog",
description=prompt,
- origin_product=Task.OriginProduct.ONBOARDING,
+ profile=WIZARD,
user_id=user_id,
repository=repository,
+ options=TaskRunOptions(
+ adapter=WIZARD_CLOUD_RUN_RUNTIME_ADAPTER, model=WIZARD_CLOUD_RUN_MODEL, mcp_scopes="read_only"
+ ),
create_pr=True,
mode="background",
branch=branch,
wizard_config={},
wizard_head_branch=head_branch,
- posthog_mcp_scopes="read_only",
- runtime_adapter=WIZARD_CLOUD_RUN_RUNTIME_ADAPTER,
- model=WIZARD_CLOUD_RUN_MODEL,
ai_stage=WIZARD_CLOUD_RUN_AI_STAGE,
# The agent server boots idle; this is the message that actually kicks it off once ready
# (delivered by forward_pending_user_message). Without it the run stalls after "Started agent".
@@ -2388,7 +2389,7 @@ def create_channel_task(team_id: int, user_id: int, channel_id: str | UUID, *, t
return create_task_without_run(
team=Team.objects.get(id=team_id),
user_id=user_id,
- origin_product=Task.OriginProduct.USER_CREATED,
+ profile=USER,
title=title,
description=description,
channel=channel,
@@ -11594,16 +11595,18 @@ def start_space_setup(
description=build_space_setup_prompt(
team_id=team.id, channel_id=str(channel.id), channel_name=channel.name, request=request
),
- origin_product=Task.OriginProduct.SPACE_SETUP,
+ profile=SPACE_SETUP,
user_id=user_id,
channel=channel,
repository=repository,
+ options=TaskRunOptions(
+ adapter=SPACE_SETUP_RUNTIME_ADAPTER,
+ model=SPACE_SETUP_MODEL,
+ reasoning_effort=SPACE_SETUP_REASONING_EFFORT,
+ mcp_scopes=[*contracts.SPACE_SETUP_SCOPES, CONTEXT_LAYER_INTERNAL_SCOPE],
+ permission_mode="auto",
+ ),
create_pr=False,
- posthog_mcp_scopes=[*contracts.SPACE_SETUP_SCOPES, CONTEXT_LAYER_INTERNAL_SCOPE],
- runtime_adapter=SPACE_SETUP_RUNTIME_ADAPTER,
- model=SPACE_SETUP_MODEL,
- reasoning_effort=SPACE_SETUP_REASONING_EFFORT,
- initial_permission_mode="auto",
client_provenance=client_provenance,
)
except ValueError as e:
diff --git a/products/tasks/backend/facade/canvas_tasks.py b/products/tasks/backend/facade/canvas_tasks.py
index 8fc8dc5d6f0d..20927e3c63e3 100644
--- a/products/tasks/backend/facade/canvas_tasks.py
+++ b/products/tasks/backend/facade/canvas_tasks.py
@@ -6,6 +6,7 @@ from django.db import transaction
from products.tasks.backend.facade import api
from products.tasks.backend.facade.contracts import TaskRunDTO
from products.tasks.backend.models import Channel, Task
+from products.tasks.backend.task_profiles import USER
from products.tasks.backend.task_sources import idempotency_key_q
@@ -52,6 +53,7 @@ def create_and_run_channel_task(
"description": description,
"channel": channel,
"origin_key": origin_key,
+ "profile": USER.key,
},
)
result = api.run_task(task.id, team_id, user_id, validated_data=run_options)
diff --git a/products/tasks/backend/facade/profiles.py b/products/tasks/backend/facade/profiles.py
index 0ac3972a77d9..db42f8112a01 100644
--- a/products/tasks/backend/facade/profiles.py
+++ b/products/tasks/backend/facade/profiles.py
@@ -22,12 +22,6 @@ class DrivePolicy(StrEnum):
NONE = "none"
-class AccessGate(StrEnum):
- DESKTOP_CODE = "desktop_code"
- INBOX = "inbox"
- NONE = "none"
-
-
class GithubResolution(StrEnum):
ALWAYS = "always"
WITH_REPOSITORY = "with_repository"
@@ -48,6 +42,7 @@ class PrAuthorship(StrEnum):
class WarmQuota(StrEnum):
NONE = "none"
AI_CREDITS = "ai_credits"
+ POSTHOG_AI = "posthog_ai"
class GithubAccess(StrEnum):
@@ -148,9 +143,6 @@ class TaskProfile:
# AUDIENCE means anyone who can read the task, such as the people in a Slack thread.
# NONE means nobody, for tasks that finish on their own.
drive: DrivePolicy
- # A check on the person that runs at create and again on every wake. DESKTOP_CODE requires
- # PostHog Code access in the organization. INBOX requires inbox access. NONE runs no check.
- access_gate: AccessGate
# The most queued or running tasks one person may have on this profile at once. Create and
# wake refuse at the cap. None means no cap.
max_live_per_user: int | None
@@ -311,7 +303,6 @@ _ORIGIN_SCOPED_FIELDS = (
"read_without_channel",
"drive",
"api_visible",
- "access_gate",
"idle_minutes",
"max_wake_minutes",
"warm",
diff --git a/products/tasks/backend/facade/temporal.py b/products/tasks/backend/facade/temporal.py
index 2fcb05122421..ff8a2b56dcab 100644
--- a/products/tasks/backend/facade/temporal.py
+++ b/products/tasks/backend/facade/temporal.py
@@ -38,6 +38,7 @@ from products.tasks.backend.temporal.process_task.activities.post_slack_update i
PostSlackUpdateInput,
post_slack_update,
)
+from products.tasks.backend.temporal.process_task.utils import mcp_exclude_tools_for_task
from products.tasks.backend.temporal.process_task.workflow import ProcessTaskWorkflow
__all__ = [
@@ -65,6 +66,7 @@ __all__ = [
"execute_posthog_code_agent_relay_workflow",
"execute_task_processing_workflow",
"execute_task_processing_workflow_async",
+ "mcp_exclude_tools_for_task",
"post_slack_update",
"resume_task_in_cloud_workflow",
"signal_task_followup_message",
diff --git a/products/tasks/backend/facade/warm.py b/products/tasks/backend/facade/warm.py
index 8a24a4f65b49..414edb5a5ed6 100644
--- a/products/tasks/backend/facade/warm.py
+++ b/products/tasks/backend/facade/warm.py
@@ -14,6 +14,7 @@ from posthog.models.team import Team
from posthog.models.user import User
from products.tasks.backend.facade import contracts
+from products.tasks.backend.facade.profiles import TaskProfile
from products.tasks.backend.logic.services.warm import SandboxWarmer, WarmResult
from products.tasks.backend.models import Task
@@ -37,16 +38,18 @@ def _warm_result_to_dto(result: WarmResult) -> contracts.WarmRunDTO:
)
-def enforce_warm_quota(origin_product: str, team_id: int, user_id: int) -> None:
+def enforce_warm_quota(origin_product: str, team_id: int, user_id: int, *, profile: TaskProfile | None = None) -> None:
"""Raise if the team may not warm a sandbox run for the origin product."""
team, user = _team_and_user(team_id, user_id)
- SandboxWarmer.enforce_quota(origin_product, team, user)
+ SandboxWarmer.enforce_quota(origin_product, team, user, profile=profile)
-def warm_pool_at_capacity(origin_product: str, team_id: int, user_id: int) -> bool:
+def warm_pool_at_capacity(
+ origin_product: str, team_id: int, user_id: int, *, profile: TaskProfile | None = None
+) -> bool:
"""Whether the user or organization already holds the max concurrent warm runs."""
team, user = _team_and_user(team_id, user_id)
- return SandboxWarmer.at_capacity(origin_product, team, user)
+ return SandboxWarmer.at_capacity(origin_product, team, user, profile=profile)
def warm_task_run(
diff --git a/products/tasks/backend/logic/repo_selection/agent.py b/products/tasks/backend/logic/repo_selection/agent.py
index dbd286175d9c..961885d4d24e 100644
--- a/products/tasks/backend/logic/repo_selection/agent.py
+++ b/products/tasks/backend/logic/repo_selection/agent.py
@@ -19,6 +19,7 @@ from posthog.models.team.team import Team
from posthog.models.user_integration import UserGitHubIntegration, UserIntegration
from posthog.sync import database_sync_to_async
+from products.tasks.backend.facade.profiles import TaskProfile, TaskSource
from products.tasks.backend.logic.repo_selection.types import RepoSelectionResult
from products.tasks.backend.logic.services.custom_prompt_internals import CustomPromptSandboxContext
from products.tasks.backend.logic.services.custom_prompt_multi_turn_runner import MultiTurnSession
@@ -689,8 +690,10 @@ async def select_repository(
user_id: int,
context: str,
*,
- origin_product: Task.OriginProduct,
+ profile: TaskProfile | None = None,
priority: Priority,
+ origin_product: Task.OriginProduct | None = None,
+ source: TaskSource | None = None,
github: GitHubIntegrationBase | None = None,
candidate_repos: list[str] | None = None,
step_name: str = "repo_selection",
@@ -843,11 +846,13 @@ async def select_repository(
step_name=step_name,
verbose=verbose,
output_fn=output_fn,
+ profile=profile,
+ source=source,
origin_product=origin_product,
signal_report_id=signal_report_id,
+ internal=True,
spend_signal_id=spend_signal_id,
ai_stage="repo_selection",
- internal=True,
on_task_run_created=_session_created,
fallback_from_text=_salvage,
json_retry_prompt=REPO_SELECTION_JSON_RETRY_PROMPT,
diff --git a/products/tasks/backend/logic/services/custom_prompt_internals.py b/products/tasks/backend/logic/services/custom_prompt_internals.py
index 88eae2fb8c2e..4aba043bd4a8 100644
--- a/products/tasks/backend/logic/services/custom_prompt_internals.py
+++ b/products/tasks/backend/logic/services/custom_prompt_internals.py
@@ -24,6 +24,7 @@ from posthog.temporal.oauth import PosthogMcpScopes
from products.tasks.backend.facade.api import upload_task_run_artifacts
from products.tasks.backend.facade.contracts import AgentStartupFailure, AgentTaskRunDTO, SessionFile
+from products.tasks.backend.facade.profiles import TaskProfile, TaskRunOptions, TaskSource
from products.tasks.backend.logic.services.startup_failure import (
AgentStartupFailed,
SandboxRunFailed as SandboxRunFailed,
@@ -330,15 +331,18 @@ def _with_session_files(
async def _create_task_and_trigger(
description: str,
context: CustomPromptSandboxContext,
+ *,
+ profile: TaskProfile | None = None,
branch: str | None = None,
step_name: str = "",
+ source: TaskSource | None = None,
origin_product: Task.OriginProduct | None = None,
signal_report_id: str | None = None,
+ internal: bool = False,
+ mcp_builtin_agent_key: MCPBuiltInAgentKey | None = None,
ai_stage: str | None = None,
ai_agent_name: str | None = None,
- internal: bool = False,
workflow_id_prefix: str | None = None,
- mcp_builtin_agent_key: MCPBuiltInAgentKey | None = None,
mcp_credential_owner_id: int | None = None,
mcp_gateway_server_ids: list[str] | None = None,
mcp_tool_allowlist: list[str] | None = None,
@@ -351,11 +355,33 @@ async def _create_task_and_trigger(
) -> tuple[Task, TaskRun]:
title = f"[sandbox_prompt:{step_name}] {description[:80]}" if step_name else description[:100]
team = await sync_to_async(Team.objects.get)(id=context.team_id)
- # Mirror Task.create_and_run's "full" default when the caller didn't set scopes — passing
- # None would clobber it. sandbox_environment_id already accepts None.
- posthog_mcp_scopes: PosthogMcpScopes = (
- context.posthog_mcp_scopes if context.posthog_mcp_scopes is not None else "full"
- )
+ task_kwargs: dict[str, Any]
+ if profile is not None:
+ task_kwargs = {
+ "profile": profile,
+ "source": source,
+ "options": TaskRunOptions(
+ adapter=context.runtime_adapter,
+ model=context.model,
+ reasoning_effort=context.reasoning_effort,
+ output_schema=output_schema,
+ mcp_scopes=context.posthog_mcp_scopes,
+ permission_mode=context.initial_permission_mode,
+ ),
+ }
+ else:
+ task_kwargs = {
+ "origin_product": origin_product or Task.OriginProduct.USER_CREATED,
+ "signal_report_id": signal_report_id,
+ "internal": internal,
+ "mcp_builtin_agent_key": mcp_builtin_agent_key,
+ "posthog_mcp_scopes": context.posthog_mcp_scopes if context.posthog_mcp_scopes is not None else "full",
+ "model": context.model,
+ "runtime_adapter": context.runtime_adapter,
+ "reasoning_effort": context.reasoning_effort,
+ "initial_permission_mode": context.initial_permission_mode,
+ "output_schema": output_schema,
+ }
extra_run_state: dict[str, Any] = {}
if context.system_prompt is not None:
extra_run_state["systemPrompt"] = context.system_prompt
@@ -381,32 +407,23 @@ async def _create_task_and_trigger(
team=team,
title=title,
description=description,
- origin_product=origin_product or Task.OriginProduct.USER_CREATED,
user_id=context.user_id,
repository=context.repository,
repositories=list(context.repositories) or None,
create_pr=False,
mode="background",
branch=branch,
- signal_report_id=signal_report_id,
spend_signal_id=spend_signal_id,
ai_stage=ai_stage,
ai_agent_name=ai_agent_name,
- posthog_mcp_scopes=posthog_mcp_scopes,
sandbox_environment_id=context.sandbox_environment_id,
- model=context.model,
- runtime_adapter=context.runtime_adapter,
runtime=context.runtime,
pending_user_message=description if context.runtime == "pi" else None,
- reasoning_effort=context.reasoning_effort,
service_tier=context.service_tier,
- initial_permission_mode=context.initial_permission_mode,
- internal=internal,
sandbox_resources=context.sandbox_resources,
sandbox_timeout_seconds=context.sandbox_timeout_seconds,
workflow_id_prefix=workflow_id_prefix,
github_read_access=context.github_read_access,
- mcp_builtin_agent_key=mcp_builtin_agent_key,
mcp_credential_owner_id=mcp_credential_owner_id,
mcp_gateway_server_ids=mcp_gateway_server_ids,
mcp_tool_allowlist=mcp_tool_allowlist,
@@ -414,7 +431,7 @@ async def _create_task_and_trigger(
extra_run_state=extra_run_state,
origin_key=origin_key,
before_task_dispatch=before_task_dispatch,
- output_schema=output_schema,
+ **task_kwargs,
)
# lambda wrap: task.latest_run is a lazy ORM property; sync_to_async needs a callable
task_run = await sync_to_async(lambda: task.latest_run)()
@@ -426,15 +443,18 @@ async def _create_task_and_trigger(
async def create_task_and_trigger(
description: str,
context: CustomPromptSandboxContext,
+ *,
+ profile: TaskProfile | None = None,
branch: str | None = None,
step_name: str = "",
+ source: TaskSource | None = None,
origin_product: Task.OriginProduct | None = None,
signal_report_id: str | None = None,
+ internal: bool = False,
+ mcp_builtin_agent_key: MCPBuiltInAgentKey | None = None,
ai_stage: str | None = None,
ai_agent_name: str | None = None,
- internal: bool = False,
workflow_id_prefix: str | None = None,
- mcp_builtin_agent_key: MCPBuiltInAgentKey | None = None,
mcp_credential_owner_id: int | None = None,
mcp_gateway_server_ids: list[str] | None = None,
output_schema: dict[str, Any] | None = None,
@@ -444,16 +464,18 @@ async def create_task_and_trigger(
task, task_run = await _create_task_and_trigger(
description,
context,
+ profile=profile,
branch=branch,
step_name=step_name,
+ source=source,
origin_product=origin_product,
signal_report_id=signal_report_id,
+ internal=internal,
+ mcp_builtin_agent_key=mcp_builtin_agent_key,
spend_signal_id=spend_signal_id,
ai_stage=ai_stage,
ai_agent_name=ai_agent_name,
- internal=internal,
workflow_id_prefix=workflow_id_prefix,
- mcp_builtin_agent_key=mcp_builtin_agent_key,
mcp_credential_owner_id=mcp_credential_owner_id,
mcp_gateway_server_ids=mcp_gateway_server_ids,
output_schema=output_schema,
diff --git a/products/tasks/backend/logic/services/custom_prompt_multi_turn_runner.py b/products/tasks/backend/logic/services/custom_prompt_multi_turn_runner.py
index 0288718c5fd3..4aea60a2c51c 100644
--- a/products/tasks/backend/logic/services/custom_prompt_multi_turn_runner.py
+++ b/products/tasks/backend/logic/services/custom_prompt_multi_turn_runner.py
@@ -13,6 +13,7 @@ from pydantic import BaseModel, JsonValue, ValidationError
from products.tasks.backend.facade.api import record_run_failure_cause
from products.tasks.backend.facade.contracts import SessionFile
+from products.tasks.backend.facade.profiles import TaskProfile, TaskSource
from products.tasks.backend.models import MCPBuiltInAgentKey, Task, TaskRun
if TYPE_CHECKING:
@@ -85,16 +86,19 @@ class MultiTurnSession:
context: CustomPromptSandboxContext,
model: type[_ModelT],
*,
+ profile: TaskProfile | None = None,
branch: str | None = None,
step_name: str = "",
verbose: bool = False,
output_fn: OutputFn = None,
+ source: TaskSource | None = None,
origin_product: Task.OriginProduct | None = None,
signal_report_id: str | None = None,
+ internal: bool = False,
+ mcp_builtin_agent_key: MCPBuiltInAgentKey | None = None,
spend_signal_id: str | None = None,
ai_stage: str | None = None,
ai_agent_name: str | None = None,
- internal: bool = False,
on_task_run_created: Callable[[TaskRun], Awaitable[None]] | None = None,
before_task_dispatch: Callable[[UUID], dict[str, JsonValue] | None] | None = None,
origin_key: str | None = None,
@@ -102,7 +106,6 @@ class MultiTurnSession:
fallback_from_text: Callable[[str], _ModelT] | None = None,
json_retry_prompt: str | None = None,
workflow_id_prefix: str | None = None,
- mcp_builtin_agent_key: MCPBuiltInAgentKey | None = None,
mcp_credential_owner_id: int | None = None,
mcp_gateway_server_ids: list[str] | None = None,
mcp_tool_allowlist: list[str] | None = None,
@@ -134,22 +137,24 @@ class MultiTurnSession:
session, last_message = await cls.start_raw(
prompt=prompt,
context=context,
+ profile=profile,
branch=branch,
step_name=step_name,
verbose=verbose,
output_fn=output_fn,
+ source=source,
origin_product=origin_product,
signal_report_id=signal_report_id,
+ internal=internal,
+ mcp_builtin_agent_key=mcp_builtin_agent_key,
spend_signal_id=spend_signal_id,
ai_stage=ai_stage,
ai_agent_name=ai_agent_name,
- internal=internal,
on_task_run_created=on_task_run_created,
before_task_dispatch=before_task_dispatch,
origin_key=origin_key,
max_poll_seconds=max_poll_seconds,
workflow_id_prefix=workflow_id_prefix,
- mcp_builtin_agent_key=mcp_builtin_agent_key,
mcp_credential_owner_id=mcp_credential_owner_id,
mcp_gateway_server_ids=mcp_gateway_server_ids,
mcp_tool_allowlist=mcp_tool_allowlist,
@@ -216,23 +221,25 @@ class MultiTurnSession:
prompt: str,
context: CustomPromptSandboxContext,
*,
+ profile: TaskProfile | None = None,
branch: str | None = None,
step_name: str = "",
verbose: bool = False,
output_fn: OutputFn = None,
+ source: TaskSource | None = None,
origin_product: Task.OriginProduct | None = None,
signal_report_id: str | None = None,
+ internal: bool = False,
+ mcp_builtin_agent_key: MCPBuiltInAgentKey | None = None,
spend_signal_id: str | None = None,
ai_stage: str | None = None,
ai_agent_name: str | None = None,
- internal: bool = False,
on_task_run_created: Callable[[TaskRun], Awaitable[None]] | None = None,
before_task_dispatch: Callable[[UUID], dict[str, JsonValue] | None] | None = None,
origin_key: str | None = None,
max_poll_seconds: int | None = None,
poll_deadline: float | None = None,
workflow_id_prefix: str | None = None,
- mcp_builtin_agent_key: MCPBuiltInAgentKey | None = None,
mcp_credential_owner_id: int | None = None,
mcp_gateway_server_ids: list[str] | None = None,
mcp_tool_allowlist: list[str] | None = None,
@@ -267,16 +274,18 @@ class MultiTurnSession:
task, task_run = await create_task_and_trigger(
prompt,
context,
+ profile=profile,
branch=branch,
step_name=step_name,
+ source=source,
origin_product=origin_product,
signal_report_id=signal_report_id,
+ internal=internal,
+ mcp_builtin_agent_key=mcp_builtin_agent_key,
spend_signal_id=spend_signal_id,
ai_stage=ai_stage,
ai_agent_name=ai_agent_name,
- internal=internal,
workflow_id_prefix=workflow_id_prefix,
- mcp_builtin_agent_key=mcp_builtin_agent_key,
mcp_credential_owner_id=mcp_credential_owner_id,
mcp_gateway_server_ids=mcp_gateway_server_ids,
mcp_tool_allowlist=mcp_tool_allowlist,
diff --git a/products/tasks/backend/logic/services/image_builder.py b/products/tasks/backend/logic/services/image_builder.py
index 4993bfb22bae..be0e1ae01e0a 100644
--- a/products/tasks/backend/logic/services/image_builder.py
+++ b/products/tasks/backend/logic/services/image_builder.py
@@ -8,6 +8,7 @@ from products.tasks.backend.constants import (
vm_sandbox_default_base_origin_products,
vm_sandbox_origin_rollout_percentages,
)
+from products.tasks.backend.facade.profiles import TaskRunOptions
from products.tasks.backend.logic.services.image_spec import (
SANDBOX_IMAGE_SPEC_PATH,
SandboxImageSpec,
@@ -15,6 +16,7 @@ from products.tasks.backend.logic.services.image_spec import (
parse_image_spec_yaml,
)
from products.tasks.backend.models import SandboxCustomImage, Task, TaskRun
+from products.tasks.backend.task_profiles import IMAGE_BUILDER
logger = logging.getLogger(__name__)
@@ -127,15 +129,15 @@ def ensure_image_builder_task(image: SandboxCustomImage, user_id: int) -> Task:
team=image.team,
title=f"Custom image: {image.name}",
description=f"Image-builder session for custom sandbox image '{image.name}'",
- origin_product=Task.OriginProduct.IMAGE_BUILDER,
+ profile=IMAGE_BUILDER,
user_id=user_id,
repository=image.repository or None,
+ options=TaskRunOptions(
+ adapter="claude", model=IMAGE_BUILDER_MODEL, reasoning_effort=IMAGE_BUILDER_REASONING_EFFORT
+ ),
create_pr=False,
mode="interactive",
interaction_origin="desktop",
- runtime_adapter="claude",
- model=IMAGE_BUILDER_MODEL,
- reasoning_effort=IMAGE_BUILDER_REASONING_EFFORT,
pending_user_message=build_image_builder_prompt(image),
custom_image_builder_id=str(image.id),
)
diff --git a/products/tasks/backend/logic/services/task_analysis.py b/products/tasks/backend/logic/services/task_analysis.py
index d692e3e18049..931a2cb8856d 100644
--- a/products/tasks/backend/logic/services/task_analysis.py
+++ b/products/tasks/backend/logic/services/task_analysis.py
@@ -24,6 +24,7 @@ from products.tasks.backend.constants import (
TASK_ANALYSIS_ACTIVITIES_STATE_KEY,
)
from products.tasks.backend.facade.contracts import TaskAnalysisError
+from products.tasks.backend.facade.profiles import TaskRunOptions
from products.tasks.backend.logic.services.staged_artifacts import (
RUN_ARTIFACT_TTL_DAYS,
build_task_artifact_entry,
@@ -31,6 +32,7 @@ from products.tasks.backend.logic.services.staged_artifacts import (
tag_task_artifact,
)
from products.tasks.backend.models import SandboxCustomImage, Task, TaskRun
+from products.tasks.backend.task_profiles import TASK_ANALYSIS
from products.tasks.backend.task_sources import idempotency_key_startswith_q
logger = structlog.get_logger(__name__)
@@ -263,20 +265,18 @@ def create_task_analysis(*, team: Team, user_id: int, target_task: Task, target_
team=team,
title=f"Task analysis: {target_task.title[:120]}",
description=prompt,
- origin_product=Task.OriginProduct.TASK_ANALYSIS,
+ profile=TASK_ANALYSIS,
user_id=user_id,
- repository=None,
+ options=TaskRunOptions(
+ adapter=TASK_ANALYSIS_RUNTIME_ADAPTER, model=TASK_ANALYSIS_MODEL, mcp_scopes="read_only"
+ ),
create_pr=False,
mode="background",
start_workflow=False,
origin_key=origin_key,
- posthog_mcp_scopes="read_only",
- runtime_adapter=TASK_ANALYSIS_RUNTIME_ADAPTER,
- model=TASK_ANALYSIS_MODEL,
pending_user_message=prompt,
extra_run_state=extra_run_state,
inactivity_timeout_seconds=TASK_ANALYSIS_INACTIVITY_TIMEOUT_SECONDS,
- internal=True,
)
except IntegrityError:
claimed = find_existing_analysis_task(team_id=team.id, target_run_id=str(target_run.id))
diff --git a/products/tasks/backend/logic/services/tests/test_warm.py b/products/tasks/backend/logic/services/tests/test_warm.py
index 44f8486f3939..58cc7d81dee5 100644
--- a/products/tasks/backend/logic/services/tests/test_warm.py
+++ b/products/tasks/backend/logic/services/tests/test_warm.py
@@ -1,7 +1,8 @@
+from dataclasses import replace
from datetime import datetime, timedelta
from posthog.test.base import APIBaseTest
-from unittest.mock import patch
+from unittest.mock import MagicMock, patch
from django.utils import timezone
@@ -14,6 +15,7 @@ from posthog.models.team import Team
from products.signals.backend.models import SignalReport
from products.tasks.backend.access import PostHogAIAccessDecision
from products.tasks.backend.constants import DEFAULT_SANDBOX_WORKING_DIR
+from products.tasks.backend.facade.profiles import WarmPolicy, WarmQuota, get_task_profile
from products.tasks.backend.logic.services.warm import ActiveSessionCaps, SandboxWarmer, WarmSourceChanged
from products.tasks.backend.models import SandboxSession, Task, TaskRun
@@ -530,3 +532,107 @@ class TestSandboxWarmerAtCapacity(APIBaseTest):
)
assert scope == expected
+
+
+class TestSandboxWarmerProfilePolicy(APIBaseTest):
+ @staticmethod
+ def _profile(origin: str, warm: WarmPolicy | None):
+ return replace(get_task_profile("user"), key="test.warm", origin_product=origin, warm=warm)
+
+ def _warm_runs(self, count: int) -> None:
+ for _ in range(count):
+ task = Task.objects.create(
+ team=self.team,
+ title="",
+ description="",
+ origin_product=Task.OriginProduct.POSTHOG_AI,
+ created_by=self.user,
+ )
+ task.create_run(mode="interactive", extra_state={"await_user_message": True})
+
+ @parameterized.expand(
+ [
+ (
+ "profile_without_warm_denies_a_warmable_origin",
+ Task.OriginProduct.POSTHOG_AI,
+ None,
+ False,
+ True,
+ PermissionDenied,
+ ),
+ (
+ "profile_warm_allows_an_origin_the_registry_denies",
+ Task.OriginProduct.ERROR_TRACKING,
+ WarmPolicy(quota=WarmQuota.AI_CREDITS, per_user_cap=2, per_org_cap=10, feature_flag=None),
+ False,
+ True,
+ None,
+ ),
+ (
+ "profile_ai_credits_quota_blocks_a_limited_team",
+ Task.OriginProduct.ERROR_TRACKING,
+ WarmPolicy(quota=WarmQuota.AI_CREDITS, per_user_cap=2, per_org_cap=10, feature_flag=None),
+ True,
+ True,
+ QuotaLimitExceeded,
+ ),
+ (
+ "profile_without_a_quota_ignores_the_credit_limit",
+ Task.OriginProduct.POSTHOG_AI,
+ WarmPolicy(quota=WarmQuota.NONE, per_user_cap=2, per_org_cap=10, feature_flag=None),
+ True,
+ True,
+ None,
+ ),
+ (
+ "profile_posthog_ai_quota_refuses_a_user_without_access",
+ Task.OriginProduct.POSTHOG_AI,
+ WarmPolicy(quota=WarmQuota.POSTHOG_AI, per_user_cap=2, per_org_cap=10, feature_flag=None),
+ False,
+ False,
+ PermissionDenied,
+ ),
+ (
+ "profile_posthog_ai_quota_still_checks_credits",
+ Task.OriginProduct.POSTHOG_AI,
+ WarmPolicy(quota=WarmQuota.POSTHOG_AI, per_user_cap=2, per_org_cap=10, feature_flag=None),
+ True,
+ True,
+ QuotaLimitExceeded,
+ ),
+ ]
+ )
+ def test_enforce_quota_follows_the_profile(self, _name, origin, warm, team_limited, access_allowed, expected_error):
+ profile = self._profile(origin, warm)
+ access = MagicMock(allowed=access_allowed)
+
+ with (
+ patch(f"{WARM}.is_team_limited", return_value=team_limited),
+ patch(f"{WARM}.get_posthog_ai_access_decision", return_value=access),
+ ):
+ if expected_error is None:
+ SandboxWarmer.enforce_quota(origin, self.team, self.user, profile=profile)
+ else:
+ with self.assertRaises(expected_error):
+ SandboxWarmer.enforce_quota(origin, self.team, self.user, profile=profile)
+
+ @parameterized.expand(
+ [
+ ("user_cap_below_the_origin_cap", 1, 10, 1, True),
+ ("user_cap_above_the_origin_cap", 3, 10, _CAPS.per_user, False),
+ ("org_cap_below_the_origin_cap", 10, 1, 1, True),
+ ]
+ )
+ def test_at_capacity_follows_the_profile_caps(self, _name, per_user_cap, per_org_cap, existing_warm_runs, expected):
+ warm = WarmPolicy(quota=WarmQuota.NONE, per_user_cap=per_user_cap, per_org_cap=per_org_cap, feature_flag=None)
+ profile = self._profile(Task.OriginProduct.POSTHOG_AI, warm)
+ self._warm_runs(existing_warm_runs)
+
+ assert (
+ SandboxWarmer.at_capacity(Task.OriginProduct.POSTHOG_AI, self.team, self.user, profile=profile) is expected
+ )
+
+ def test_at_capacity_without_a_profile_uses_the_origin_caps(self):
+ self._warm_runs(_CAPS.per_user)
+
+ assert SandboxWarmer.at_capacity(Task.OriginProduct.POSTHOG_AI, self.team, self.user) is True
diff --git a/products/tasks/backend/logic/services/warm.py b/products/tasks/backend/logic/services/warm.py
index 25dd8eebfee4..2f72ab3e3bd9 100644
--- a/products/tasks/backend/logic/services/warm.py
+++ b/products/tasks/backend/logic/services/warm.py
@@ -31,6 +31,7 @@ from posthog.models.team import Team
from posthog.models.user import User
from products.tasks.backend.access import get_posthog_ai_access_decision
+from products.tasks.backend.facade.profiles import TaskProfile, WarmQuota
from products.tasks.backend.logic.services.compute_quota import organization_deactivated
from products.tasks.backend.logic.services.workflow_dispatch import WorkflowDispatchOptions, enqueue_or_start_workflow
from products.tasks.backend.metrics import observe_warm_churn_throttled
@@ -104,6 +105,13 @@ def _posthog_ai_checker(team: Team, user: User) -> None:
_ai_credits_checker(team, user)
+_CHECKERS_BY_WARM_QUOTA: dict[WarmQuota, Callable[[Team, User], None] | None] = {
+ WarmQuota.AI_CREDITS: _ai_credits_checker,
+ WarmQuota.POSTHOG_AI: _posthog_ai_checker,
+ WarmQuota.NONE: None,
+}
+
+
class SandboxWarmer:
"""Idempotently warm a sandbox Run for an existing Task, enforcing the product's quota gate and a
state-derived warm-pool cap, then dispatching the processing workflow after commit.
@@ -149,22 +157,28 @@ class SandboxWarmer:
self.user = user
@classmethod
- def enforce_quota(cls, origin_product: str, team: Team, user: User) -> None:
+ def enforce_quota(cls, origin_product: str, team: Team, user: User, *, profile: TaskProfile | None = None) -> None:
"""Raise if ``team`` may not warm a Run for ``origin_product`` (over quota, or origin not registered).
Fail-closed: an origin absent from the registry is denied. A registered origin whose gate is
- ``None`` is allowed with no billing quota (enablement + caps gate it elsewhere).
+ ``None`` is allowed with no billing quota (enablement + caps gate it elsewhere). A profile
+ answers from its warm policy instead of the origin registry.
"""
- if origin_product not in cls.ORIGIN_PRODUCT_QUOTA:
- raise PermissionDenied(f"Warming is not enabled for origin product '{origin_product}'.")
+ if profile is not None:
+ if profile.warm is None:
+ raise PermissionDenied(f"Warming is not enabled for origin product '{origin_product}'.")
+ checker = _CHECKERS_BY_WARM_QUOTA[profile.warm.quota]
+ else:
+ if origin_product not in cls.ORIGIN_PRODUCT_QUOTA:
+ raise PermissionDenied(f"Warming is not enabled for origin product '{origin_product}'.")
+ checker = cls.ORIGIN_PRODUCT_QUOTA[origin_product]
if organization_deactivated(team.id):
raise PermissionDenied("Your organization has been deactivated.")
- checker = cls.ORIGIN_PRODUCT_QUOTA[origin_product]
if checker is not None:
checker(team, user)
@classmethod
- def at_capacity(cls, origin_product: str, team: Team, user: User) -> bool:
+ def at_capacity(cls, origin_product: str, team: Team, user: User, *, profile: TaskProfile | None = None) -> bool:
"""True if the user or org already holds the max concurrent *warm* Runs.
Counts only Runs still awaiting their first message (``state.await_user_message`` set) — so the
@@ -174,7 +188,10 @@ class SandboxWarmer:
serialized by the per-Task lock, so it may overshoot slightly under heavy concurrency — acceptable
for a best-effort resource guard.
"""
- caps = cls.ORIGIN_PRODUCT_CAPS.get(origin_product, cls._DEFAULT_CAPS)
+ if profile is not None and profile.warm is not None:
+ caps = WarmPoolCaps(per_user=profile.warm.per_user_cap, per_org=profile.warm.per_org_cap)
+ else:
+ caps = cls.ORIGIN_PRODUCT_CAPS.get(origin_product, cls._DEFAULT_CAPS)
# `await_user_message` is stored literally (the field is alias-free in PostHogAIRunState); see the
# comment there before adding an alias, which would silently break this filter and open the cap.
warm_runs = TaskRun.objects.filter(
@@ -321,10 +338,11 @@ class SandboxWarmer:
"""
# Quota is a gateway/cache call — check it before taking the row lock, never while holding it.
origin_product = self.task.origin_product
+ profile = self.task.stored_profile
team = self.task.team
- self.enforce_quota(origin_product, team, self.user)
+ self.enforce_quota(origin_product, team, self.user, profile=profile)
churned = self._warm_churn_exceeded()
- pool_full = self.at_capacity(origin_product, team, self.user)
+ pool_full = self.at_capacity(origin_product, team, self.user, profile=profile)
new_run: TaskRun
with transaction.atomic():
diff --git a/products/tasks/backend/task_profiles.py b/products/tasks/backend/task_profiles.py
new file mode 100644
index 000000000000..7325847d66d9
--- /dev/null
+++ b/products/tasks/backend/task_profiles.py
@@ -0,0 +1,169 @@
+from dataclasses import replace
+
+from products.tasks.backend.facade.profiles import (
+ DrivePolicy,
+ GithubAccess,
+ GithubResolution,
+ NetworkAccess,
+ NetworkPolicy,
+ OAuthApp,
+ PrAuthorship,
+ Read,
+ SourceKind,
+ TaskProfile,
+ WarmPolicy,
+ WarmQuota,
+ register_task_profiles,
+)
+
+PUBLIC_RUN_OPTIONS = frozenset(
+ {
+ "runtime",
+ "adapter",
+ "model",
+ "reasoning_effort",
+ "repositories",
+ "output_schema",
+ "permission_mode",
+ "auto_publish",
+ }
+)
+PREWARM_SANDBOX_FLAG = "tasks-prewarm-sandbox"
+
+_BASE = TaskProfile(
+ key="tasks.base",
+ origin_product="",
+ public=False,
+ public_options=frozenset(),
+ source_kind=None,
+ listed=True,
+ read_without_channel=Read.CREATOR,
+ api_visible=True,
+ drive=DrivePolicy.OWNER,
+ max_live_per_user=None,
+ warm=None,
+ runtimes=("acp",),
+ sandbox_templates=("default_base",),
+ network=NetworkPolicy(levels=(NetworkAccess.FULL,)),
+ inherit_user_defaults=True,
+ personal_mcp=True,
+ mcp_agent=None,
+ mcp_scopes="full",
+ mcp_store_servers=True,
+ mcp_exclude_tools=(),
+ oauth_app=OAuthApp.ARRAY,
+ github_resolution=GithubResolution.WITH_REPOSITORY,
+ github_access=GithubAccess.WRITE,
+ user_authorable_prs=False,
+ default_pr_authorship=PrAuthorship.BOT,
+ create_pr=True,
+ finish_tool=False,
+ done_on_turn_close=False,
+ idle_minutes=30,
+ inactivity_minutes=10,
+ tool_call_minutes=None,
+ max_wake_minutes=180,
+ billing_product="posthog_code",
+ bills_compute=False,
+ max_cost_usd=None,
+ task_budget_usd=None,
+ finish_in_flight=True,
+)
+
+_PUBLIC = replace(_BASE, public=True, public_options=PUBLIC_RUN_OPTIONS)
+
+USER = replace(
+ _PUBLIC,
+ key="user",
+ origin_product="user_created",
+ runtimes=("acp", "pi"),
+ network=NetworkPolicy(levels=(NetworkAccess.FULL, NetworkAccess.TRUSTED, NetworkAccess.CUSTOM)),
+ warm=WarmPolicy(quota=WarmQuota.NONE, per_user_cap=10, per_org_cap=100, feature_flag=PREWARM_SANDBOX_FLAG),
+ github_resolution=GithubResolution.ALWAYS,
+ user_authorable_prs=True,
+ default_pr_authorship=PrAuthorship.USER,
+ idle_minutes=60,
+ max_wake_minutes=None,
+ bills_compute=True,
+)
+
+ERROR_TRACKING = replace(_PUBLIC, key="error_tracking", origin_product="error_tracking")
+EVAL_CLUSTERS = replace(_PUBLIC, key="eval_clusters", origin_product="eval_clusters")
+SUPPORT_QUEUE = replace(_PUBLIC, key="support_queue", origin_product="support_queue")
+SESSION_SUMMARIES = replace(_PUBLIC, key="session_summaries", origin_product="session_summaries")
+MCP_ANALYTICS = replace(_PUBLIC, key="mcp_analytics", origin_product="mcp_analytics")
+LOOP = replace(_PUBLIC, key="loop", origin_product="loop", mcp_scopes="read_only")
+
+HOGDESK = replace(
+ _PUBLIC, key="hogdesk", origin_product="hogdesk", read_without_channel=Read.TEAM, drive=DrivePolicy.AUDIENCE
+)
+
+WIZARD = replace(
+ _BASE,
+ key="wizard",
+ origin_product="onboarding",
+ read_without_channel=Read.TEAM,
+ drive=DrivePolicy.AUDIENCE,
+ mcp_scopes="read_only",
+ billing_product="onboarding",
+)
+
+SPACE_SETUP = replace(
+ _BASE,
+ key="space_setup",
+ origin_product="space_setup",
+ idle_minutes=60,
+ max_wake_minutes=None,
+ bills_compute=True,
+)
+
+IMAGE_BUILDER = replace(
+ _BASE,
+ key="image_builder",
+ origin_product="image_builder",
+ github_resolution=GithubResolution.ALWAYS,
+ idle_minutes=60,
+ max_wake_minutes=None,
+)
+
+TASK_ANALYSIS = replace(
+ _BASE,
+ key="task_analysis",
+ origin_product="task_analysis",
+ listed=False,
+ inherit_user_defaults=False,
+ personal_mcp=False,
+ mcp_scopes="read_only",
+ billing_product="background_agents",
+)
+
+WORKFLOW = replace(
+ _BASE,
+ key="workflow",
+ origin_product="workflow",
+ source_kind=SourceKind.HOG_FLOW,
+ read_without_channel=Read.TEAM,
+ drive=DrivePolicy.AUDIENCE,
+ mcp_agent="workflow",
+ billing_product="workflows",
+)
+
+PROFILES = (
+ USER,
+ ERROR_TRACKING,
+ EVAL_CLUSTERS,
+ SUPPORT_QUEUE,
+ SESSION_SUMMARIES,
+ MCP_ANALYTICS,
+ LOOP,
+ HOGDESK,
+ WIZARD,
+ SPACE_SETUP,
+ IMAGE_BUILDER,
+ TASK_ANALYSIS,
+ WORKFLOW,
+)
+
+
+def register() -> None:
+ register_task_profiles(PROFILES)
diff --git a/products/tasks/backend/temporal/process_task/activities/tests/test_get_task_processing_context.py b/products/tasks/backend/temporal/process_task/activities/tests/test_get_task_processing_context.py
index b78b5022367c..5669d2fa212f 100644
--- a/products/tasks/backend/temporal/process_task/activities/tests/test_get_task_processing_context.py
+++ b/products/tasks/backend/temporal/process_task/activities/tests/test_get_task_processing_context.py
@@ -485,6 +485,8 @@ class TestGetTaskProcessingContextActivity:
(None, False, False),
("business_knowledge", True, False),
("business_knowledge", False, False),
+ ("space_setup", True, True),
+ ("space_setup", False, False),
("test.unregistered", True, True),
],
)
diff --git a/products/tasks/backend/tests/test_api.py b/products/tasks/backend/tests/test_api.py
index 109c759138e3..1e020a70401c 100644
--- a/products/tasks/backend/tests/test_api.py
+++ b/products/tasks/backend/tests/test_api.py
@@ -18500,6 +18500,7 @@ class TestSandboxCustomImageAPI(BaseTaskAPITest):
task = Task.objects.get(id=data["builder_task_id"])
self.assertEqual(task.repository, "posthog/hedgebox")
self.assertEqual(task.origin_product, Task.OriginProduct.IMAGE_BUILDER)
+ self.assertEqual(task.profile, "image_builder")
run = task.runs.order_by("-created_at").first()
assert run is not None
self.assertIn("/tmp/workspace/repos/posthog/hedgebox", run.state["pending_user_message"])
@@ -18971,6 +18972,7 @@ class TestTaskRunAnalyzeAPI(BaseTaskAPITest):
self.assertTrue(body["created"])
analysis_task = Task.objects.get(id=body["analysis_task_id"])
self.assertEqual(analysis_task.origin_product, Task.OriginProduct.TASK_ANALYSIS)
+ self.assertEqual(analysis_task.profile, "task_analysis")
self.assertTrue(analysis_task.internal)
self.assertIn("analyzing-task-runs", analysis_task.description)
run = analysis_task.latest_run
diff --git a/products/tasks/backend/tests/test_channel_extras.py b/products/tasks/backend/tests/test_channel_extras.py
index 3019853c6918..41d09f320a57 100644
--- a/products/tasks/backend/tests/test_channel_extras.py
+++ b/products/tasks/backend/tests/test_channel_extras.py
@@ -183,6 +183,7 @@ class TestChannelSetup(ChannelExtrasBaseTest):
task = Task.objects.get(id=response.json()["task_id"])
assert task.channel_id == self.channel.id
assert task.origin_product == Task.OriginProduct.SPACE_SETUP
+ assert task.profile == "space_setup"
assert task.created_by_id == self.user.id
assert "Increase the weekly activation rate" in task.description
assert "posthog/posthog" in task.description
diff --git a/products/tasks/backend/tests/test_multi_turn_session.py b/products/tasks/backend/tests/test_multi_turn_session.py
index 564036fa4e50..aef7b4a20a9f 100644
--- a/products/tasks/backend/tests/test_multi_turn_session.py
+++ b/products/tasks/backend/tests/test_multi_turn_session.py
@@ -23,6 +23,7 @@ from posthog.storage.object_storage import ObjectStorageError
from products.tasks.backend.facade import agents as agents_facade
from products.tasks.backend.facade.api import _public_task_run_state
from products.tasks.backend.facade.contracts import SessionFile
+from products.tasks.backend.facade.profiles import get_task_profile
from products.tasks.backend.logic.services.custom_prompt_internals import (
AgentError,
AgentTurnFailed,
@@ -65,6 +66,9 @@ from products.tasks.backend.tests.agent_log_fixtures import (
FIXTURES_DIR = Path(__file__).parent / "fixtures"
+USER = get_task_profile("user")
+
+
class _Resp(BaseModel):
value: str
@@ -1891,6 +1895,7 @@ class TestMultiTurnSessionStartBranch:
prompt="hello",
context=context,
model=_Resp,
+ profile=USER,
**kwargs,
)
@@ -1951,6 +1956,7 @@ class TestMultiTurnSessionStartCleanup:
prompt="test",
context=CustomPromptSandboxContext(team_id=1, user_id=2),
model=_Resp,
+ profile=USER,
)
# session.end() must have signalled the workflow exactly once on the cleanup path.
@@ -1981,7 +1987,7 @@ class TestCreateTaskAndTriggerForwardsContext:
"ctx_env, ctx_scopes, expected_env, expected_scopes",
[
("env-uuid-abc", "read_only", "env-uuid-abc", "read_only"),
- (None, None, None, "full"),
+ (None, None, None, None),
(None, [], None, []),
],
)
@@ -2001,11 +2007,11 @@ class TestCreateTaskAndTriggerForwardsContext:
"products.tasks.backend.logic.services.custom_prompt_internals.Task.create_and_run",
return_value=mock_task,
) as mock_create:
- await create_task_and_trigger("prompt", context)
+ await create_task_and_trigger("prompt", context, profile=USER)
kwargs = mock_create.call_args.kwargs
assert kwargs["sandbox_environment_id"] == expected_env
- assert kwargs["posthog_mcp_scopes"] == expected_scopes
+ assert kwargs["options"].mcp_scopes == expected_scopes
@pytest.mark.asyncio
@pytest.mark.parametrize(
@@ -2027,7 +2033,7 @@ class TestCreateTaskAndTriggerForwardsContext:
"products.tasks.backend.logic.services.custom_prompt_internals.Task.create_and_run",
return_value=mock_task,
) as mock_create:
- await create_task_and_trigger("prompt", context, **{stamp: value})
+ await create_task_and_trigger("prompt", context, profile=USER, **{stamp: value})
assert mock_create.call_args.kwargs[stamp] == value
@@ -2049,7 +2055,7 @@ class TestCreateTaskAndTriggerForwardsContext:
with patch("products.tasks.backend.temporal.client.execute_task_processing_workflow"):
task_run = await agents_facade.create_task_and_trigger(
- "prompt", context, workflow_id_prefix=workflow_id_prefix, analytics_query_context=queries
+ "prompt", context, profile=USER, workflow_id_prefix=workflow_id_prefix, analytics_query_context=queries
)
persisted = await sync_to_async(TaskRun.objects.get)(id=task_run.run_id)
@@ -2098,11 +2104,11 @@ class TestCreateTaskAndTriggerForwardsContext:
if fail_initialization:
with pytest.raises(ValueError, match="Initialization failed"):
await _create_task_and_trigger(
- "prompt", context, origin_key="trial-example", before_task_dispatch=initialize
+ "prompt", context, profile=USER, origin_key="trial-example", before_task_dispatch=initialize
)
else:
task, run = await _create_task_and_trigger(
- "prompt", context, origin_key="trial-example", before_task_dispatch=initialize
+ "prompt", context, profile=USER, origin_key="trial-example", before_task_dispatch=initialize
)
assert task.origin_key == "trial-example"
assert run.state["private_ready"] is True
@@ -2128,7 +2134,11 @@ class TestCreateTaskAndTriggerForwardsContext:
patch("products.tasks.backend.temporal.client.execute_task_processing_workflow"),
):
_, run = await _create_task_and_trigger(
- "prompt", context, files=files, before_task_dispatch=lambda run_id: {"private_ready": True}
+ "prompt",
+ context,
+ profile=USER,
+ files=files,
+ before_task_dispatch=lambda run_id: {"private_ready": True},
)
persisted = await sync_to_async(TaskRun.objects.get)(id=run.id)
@@ -2152,7 +2162,7 @@ class TestCreateTaskAndTriggerForwardsContext:
)
with patch("products.tasks.backend.temporal.client.execute_task_processing_workflow"):
- task_run = await agents_facade.create_task_and_trigger("prompt", context)
+ task_run = await agents_facade.create_task_and_trigger("prompt", context, profile=USER)
persisted = await sync_to_async(TaskRun.objects.get)(id=task_run.run_id)
public_state = _public_task_run_state(persisted.state)
@@ -2167,7 +2177,9 @@ class TestCreateTaskAndTriggerForwardsContext:
context = CustomPromptSandboxContext(team_id=team.id, user_id=user.id)
with patch("products.tasks.backend.temporal.client.execute_task_processing_workflow"):
- task_run = await agents_facade.create_task_and_trigger("prompt", context, output_schema=output_schema)
+ task_run = await agents_facade.create_task_and_trigger(
+ "prompt", context, profile=USER, output_schema=output_schema
+ )
persisted = await sync_to_async(TaskRun.objects.get)(id=task_run.run_id)
assert persisted.state.get("caller_ends_run") is expected_flag
@@ -2204,14 +2216,14 @@ class TestCreateTaskAndTriggerForwardsContext:
"products.tasks.backend.logic.services.custom_prompt_internals.Task.create_and_run",
return_value=mock_task,
) as mock_create:
- await create_task_and_trigger("prompt", context)
+ await create_task_and_trigger("prompt", context, profile=USER)
- kwargs = mock_create.call_args.kwargs
+ options = mock_create.call_args.kwargs["options"]
assert (
- kwargs["model"],
- kwargs["runtime_adapter"],
- kwargs["reasoning_effort"],
- kwargs["initial_permission_mode"],
+ options.model,
+ options.adapter,
+ options.reasoning_effort,
+ options.permission_mode,
) == (model, runtime_adapter, reasoning_effort, initial_permission_mode)
@@ -2258,6 +2270,7 @@ class TestMultiTurnSessionStartFallback:
prompt="x",
context=MagicMock(),
model=_Resp,
+ profile=USER,
fallback_from_text=lambda text: _Resp(value=text),
json_retry_prompt="Return JSON" if retry_reply is not None else None,
)
@@ -2273,7 +2286,7 @@ class TestMultiTurnSessionStartFallback:
with patch.object(MultiTurnSession, "start_raw", new=AsyncMock(return_value=(session, "prose only"))):
with pytest.raises(ValueError):
- await MultiTurnSession.start(prompt="x", context=MagicMock(), model=_Resp)
+ await MultiTurnSession.start(prompt="x", context=MagicMock(), model=_Resp, profile=USER)
session.end.assert_awaited_once() # type: ignore[attr-defined]
assert session.end.await_args.kwargs.get("status") == "failed" # type: ignore[attr-defined]
@@ -2287,7 +2300,7 @@ class TestMultiTurnSessionStartFallback:
MultiTurnSession, "start_raw", new=AsyncMock(return_value=(session, json.dumps({"value": "ok"})))
):
_, parsed = await MultiTurnSession.start(
- prompt="x", context=MagicMock(), model=_Resp, fallback_from_text=fallback
+ prompt="x", context=MagicMock(), model=_Resp, profile=USER, fallback_from_text=fallback
)
assert parsed == _Resp(value="ok")
@@ -2305,7 +2318,9 @@ class TestMultiTurnSessionStartFallback:
with patch.object(MultiTurnSession, "start_raw", new=AsyncMock(return_value=(session, "prose only"))):
with pytest.raises(ValueError):
- await MultiTurnSession.start(prompt="x", context=MagicMock(), model=_Resp, fallback_from_text=boom)
+ await MultiTurnSession.start(
+ prompt="x", context=MagicMock(), model=_Resp, profile=USER, fallback_from_text=boom
+ )
session.end.assert_awaited_once() # type: ignore[attr-defined]
assert session.end.await_args.kwargs.get("status") == "failed" # type: ignore[attr-defined]
@@ -2322,7 +2337,9 @@ class TestMultiTurnSessionStartFallback:
patch.object(MultiTurnSession, "_parse_and_validate", side_effect=asyncio.CancelledError()),
):
with pytest.raises(asyncio.CancelledError):
- await MultiTurnSession.start(prompt="x", context=MagicMock(), model=_Resp, fallback_from_text=fallback)
+ await MultiTurnSession.start(
+ prompt="x", context=MagicMock(), model=_Resp, profile=USER, fallback_from_text=fallback
+ )
fallback.assert_not_called()
session.end.assert_awaited_once() # type: ignore[attr-defined]
@@ -2342,10 +2359,12 @@ class TestMultiTurnSessionStartFallback:
with patch.object(MultiTurnSession, "start_raw", new=AsyncMock(return_value=(session, "prose only"))):
if expected is None:
with pytest.raises(ValueError):
- await MultiTurnSession.start(prompt="x", context=MagicMock(), model=_Resp, json_retry_prompt="JSON")
+ await MultiTurnSession.start(
+ prompt="x", context=MagicMock(), model=_Resp, profile=USER, json_retry_prompt="JSON"
+ )
else:
_, parsed = await MultiTurnSession.start(
- prompt="x", context=MagicMock(), model=_Resp, json_retry_prompt="JSON"
+ prompt="x", context=MagicMock(), model=_Resp, profile=USER, json_retry_prompt="JSON"
)
assert parsed == expected
@@ -2367,7 +2386,12 @@ class TestMultiTurnSessionStartFallback:
with patch.object(MultiTurnSession, "start_raw", new=AsyncMock(return_value=(session, "prose only"))):
with pytest.raises(RuntimeError):
await MultiTurnSession.start(
- prompt="x", context=MagicMock(), model=_Resp, json_retry_prompt="JSON", fallback_from_text=fallback
+ prompt="x",
+ context=MagicMock(),
+ model=_Resp,
+ profile=USER,
+ json_retry_prompt="JSON",
+ fallback_from_text=fallback,
)
fallback.assert_not_called()
diff --git a/products/tasks/backend/tests/test_profile_parity.py b/products/tasks/backend/tests/test_profile_parity.py
index b0ac14ea5cc3..eeae0a42fa98 100644
--- a/products/tasks/backend/tests/test_profile_parity.py
+++ b/products/tasks/backend/tests/test_profile_parity.py
@@ -13,13 +13,12 @@ from products.tasks.backend.facade.profiles import (
Read,
TaskProfile,
WarmPolicy,
- WarmQuota,
task_profiles,
)
from products.tasks.backend.facade.run_config import WARMABLE_ORIGIN_PRODUCTS
from products.tasks.backend.logic.services.compute_quota import is_billable_compute
from products.tasks.backend.logic.services.sandbox import parse_requested_sandbox_template
-from products.tasks.backend.logic.services.warm import SandboxWarmer
+from products.tasks.backend.logic.services.warm import _CHECKERS_BY_WARM_QUOTA, SandboxWarmer
from products.tasks.backend.models import MCP_BUILT_IN_AGENT_KEY_BY_ORIGIN, Task, TaskClientProvenance
from products.tasks.backend.presentation.views.api import (
WARM_SANDBOX_FLAGS_BY_ORIGIN_PRODUCT,
@@ -73,7 +72,7 @@ def _master_warm_policy(origin_product: str) -> WarmPolicy | None:
caps = SandboxWarmer.ORIGIN_PRODUCT_CAPS.get(origin_product, SandboxWarmer._DEFAULT_CAPS)
checker = SandboxWarmer.ORIGIN_PRODUCT_QUOTA[origin_product]
return WarmPolicy(
- quota=WarmQuota.NONE if checker is None else WarmQuota.AI_CREDITS,
+ quota=next(quota for quota, check in _CHECKERS_BY_WARM_QUOTA.items() if check is checker),
per_user_cap=caps.per_user,
per_org_cap=caps.per_org,
feature_flag=None
@@ -172,6 +171,10 @@ class TestTaskProfilesMatchMaster(SimpleTestCase):
def test_default_pr_authorship_matches_master(self, _key: str, profile: TaskProfile) -> None:
self.assertEqual(profile.default_pr_authorship, get_pr_authorship_mode(_task(profile), None))
+ @parameterized.expand(PROFILES)
+ def test_create_pr_matches_master(self, _key: str, profile: TaskProfile) -> None:
+ self.assertEqual(profile.create_pr, profile.origin_product not in PRODUCT_PRIVATE_ORIGIN_PRODUCTS)
+
@parameterized.expand(PROFILES)
def test_default_runtime_matches_master(self, _key: str, profile: TaskProfile) -> None:
self.assertEqual(profile.runtimes[0], Task.Runtime.ACP)
diff --git a/products/tasks/evals/repo_selection/runner.py b/products/tasks/evals/repo_selection/runner.py
index da3f5c02b53e..5cb2aa2415b9 100644
--- a/products/tasks/evals/repo_selection/runner.py
+++ b/products/tasks/evals/repo_selection/runner.py
@@ -29,6 +29,7 @@ from products.posthog_ai.eval_harness.runner import (
from products.tasks.backend.facade import api as tasks_api
from products.tasks.backend.facade.agents import CustomPromptSandboxContext, TurnPollTimeout
from products.tasks.backend.facade.contracts import TaskRunDTO
+from products.tasks.backend.facade.profiles import TaskProfile
from products.tasks.backend.facade.repo_selection import (
RepoSelectionRejectedError,
RepoSelectionUnavailableError,
@@ -119,7 +120,8 @@ async def _select(
scenario: RepoSelectionScenario,
context: CustomPromptSandboxContext,
*,
- origin_product: tasks_api.TaskOriginProduct,
+ profile: TaskProfile | None = None,
+ origin_product: tasks_api.TaskOriginProduct | None = None,
priority: Priority,
deadline: float | None,
artifacts: RepoSelectionArtifacts,
@@ -131,6 +133,7 @@ async def _select(
team_id=context.team_id,
user_id=context.user_id,
context=scenario.context_block,
+ profile=profile,
origin_product=origin_product,
priority=priority,
sandbox_environment_id=context.sandbox_environment_id,
@@ -194,7 +197,8 @@ async def run_selector(
scenario: RepoSelectionScenario,
context: CustomPromptSandboxContext,
*,
- origin_product: tasks_api.TaskOriginProduct,
+ profile: TaskProfile | None = None,
+ origin_product: tasks_api.TaskOriginProduct | None = None,
priority: Priority,
provider: SandboxProviderStrategy,
on_cleanup: Callable[[], Awaitable[None]] | None,
@@ -217,6 +221,7 @@ async def run_selector(
_select(
scenario,
context,
+ profile=profile,
origin_product=origin_product,
priority=priority,
deadline=deadline,
@@ -262,7 +267,11 @@ async def run_selector(
def selector_case_runner(
- scenarios: dict[str, RepoSelectionScenario], *, origin_product: tasks_api.TaskOriginProduct, priority: Priority
+ scenarios: dict[str, RepoSelectionScenario],
+ *,
+ profile: TaskProfile | None = None,
+ origin_product: tasks_api.TaskOriginProduct | None = None,
+ priority: Priority,
) -> SandboxedCaseRunner:
async def run(
case: SandboxedEvalCase,
@@ -276,6 +285,7 @@ def selector_case_runner(
return await run_selector(
scenarios[case.name],
context,
+ profile=profile,
origin_product=origin_product,
priority=priority,
provider=provider,