Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
fix(SKY-12062): return 422 for send_email block with undeclared smtp params (#7260)
Aaron Pereze2600be5f234
diff --git a/docs/api-reference/openapi.json b/docs/api-reference/openapi.jsonindex 3f216317b..46f243971 100644--- a/docs/api-reference/openapi.json+++ b/docs/api-reference/openapi.json@@ -135,10 +135,8 @@"type": "null"}],- "description": "Skyvern API key for authentication. API key can be found at https://app.skyvern.com/settings.","title": "X-Api-Key"- },- "description": "Skyvern API key for authentication. API key can be found at https://app.skyvern.com/settings."+ }},{"name": "x-max-steps-override",@@ -1307,21 +1305,369 @@"examples": ["fld_123"],- "title": "Folder Id"+ "title": "Folder Id"+ },+ "description": "Folder ID"+ },+ {+ "name": "delete_workflows",+ "in": "query",+ "required": false,+ "schema": {+ "type": "boolean",+ "description": "If true, also delete all workflows in this folder",+ "default": false,+ "title": "Delete Workflows"+ },+ "description": "If true, also delete all workflows in this folder"+ },+ {+ "name": "x-api-key",+ "in": "header",+ "required": false,+ "schema": {+ "anyOf": [+ {+ "type": "string"+ },+ {+ "type": "null"+ }+ ],+ "description": "Skyvern API key for authentication. API key can be found at https://app.skyvern.com/settings.",+ "title": "X-Api-Key"+ },+ "description": "Skyvern API key for authentication. API key can be found at https://app.skyvern.com/settings."+ }+ ],+ "responses": {+ "200": {+ "description": "Successfully deleted folder",+ "content": {+ "application/json": {+ "schema": {+ "type": "object",+ "additionalProperties": true,+ "title": "Response Delete Folder V1 Folders Folder Id Delete"+ }+ }+ }+ },+ "404": {+ "description": "Folder not found"+ },+ "422": {+ "description": "Validation Error",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/HTTPValidationError"+ }+ }+ }+ }+ },+ "x-fern-sdk-method-name": "delete_folder"+ }+ },+ "/v1/runs/{workflow_run_id}/tags": {+ "post": {+ "tags": [+ "Tags"+ ],+ "summary": "Apply run tags",+ "description": "Atomically apply tag changes to a workflow run. Sets and deletes happen in one transaction; same-key collisions resolve set-wins.",+ "operationId": "apply_run_tags_v1_runs__workflow_run_id__tags_post",+ "parameters": [+ {+ "name": "workflow_run_id",+ "in": "path",+ "required": true,+ "schema": {+ "type": "string",+ "description": "Workflow run ID",+ "examples": [+ "wr_123"+ ],+ "title": "Workflow Run Id"+ },+ "description": "Workflow run ID"+ },+ {+ "name": "x-api-key",+ "in": "header",+ "required": false,+ "schema": {+ "anyOf": [+ {+ "type": "string"+ },+ {+ "type": "null"+ }+ ],+ "description": "Skyvern API key for authentication. API key can be found at https://app.skyvern.com/settings.",+ "title": "X-Api-Key"+ },+ "description": "Skyvern API key for authentication. API key can be found at https://app.skyvern.com/settings."+ }+ ],+ "requestBody": {+ "required": true,+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/TagApplyRequest"+ }+ }+ }+ },+ "responses": {+ "200": {+ "description": "Successfully applied tag changes",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/RunTagsResponse"+ }+ }+ }+ },+ "404": {+ "description": "Workflow run not found"+ },+ "422": {+ "description": "Invalid tag key or value"+ }+ },+ "x-fern-sdk-method-name": "apply_run_tags"+ },+ "get": {+ "tags": [+ "Tags"+ ],+ "summary": "Get run tags",+ "description": "Get the current tag state for a workflow run.",+ "operationId": "get_run_tags_v1_runs__workflow_run_id__tags_get",+ "parameters": [+ {+ "name": "workflow_run_id",+ "in": "path",+ "required": true,+ "schema": {+ "type": "string",+ "description": "Workflow run ID",+ "examples": [+ "wr_123"+ ],+ "title": "Workflow Run Id"+ },+ "description": "Workflow run ID"+ },+ {+ "name": "x-api-key",+ "in": "header",+ "required": false,+ "schema": {+ "anyOf": [+ {+ "type": "string"+ },+ {+ "type": "null"+ }+ ],+ "description": "Skyvern API key for authentication. API key can be found at https://app.skyvern.com/settings.",+ "title": "X-Api-Key"+ },+ "description": "Skyvern API key for authentication. API key can be found at https://app.skyvern.com/settings."+ }+ ],+ "responses": {+ "200": {+ "description": "Successfully retrieved tags",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/RunTagsResponse"+ }+ }+ }+ },+ "404": {+ "description": "Workflow run not found"+ },+ "422": {+ "description": "Validation Error",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/HTTPValidationError"+ }+ }+ }+ }+ },+ "x-fern-sdk-method-name": "get_run_tags"+ }+ },+ "/v1/runs/{workflow_run_id}/tags/{key}": {+ "delete": {+ "tags": [+ "Tags"+ ],+ "summary": "Delete run tag",+ "description": "Soft-delete a single grouped tag from a workflow run. Writes a DELETE event row.",+ "operationId": "delete_run_tag_v1_runs__workflow_run_id__tags__key__delete",+ "parameters": [+ {+ "name": "workflow_run_id",+ "in": "path",+ "required": true,+ "schema": {+ "type": "string",+ "description": "Workflow run ID",+ "examples": [+ "wr_123"+ ],+ "title": "Workflow Run Id"+ },+ "description": "Workflow run ID"+ },+ {+ "name": "key",+ "in": "path",+ "required": true,+ "schema": {+ "type": "string",+ "description": "Tag key to delete",+ "examples": [+ "env"+ ],+ "title": "Key"+ },+ "description": "Tag key to delete"+ },+ {+ "name": "x-api-key",+ "in": "header",+ "required": false,+ "schema": {+ "anyOf": [+ {+ "type": "string"+ },+ {+ "type": "null"+ }+ ],+ "description": "Skyvern API key for authentication. API key can be found at https://app.skyvern.com/settings.",+ "title": "X-Api-Key"+ },+ "description": "Skyvern API key for authentication. API key can be found at https://app.skyvern.com/settings."+ }+ ],+ "responses": {+ "200": {+ "description": "Successfully deleted tag (or no-op if absent)",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/RunTagsResponse"+ }+ }+ }+ },+ "404": {+ "description": "Workflow run not found"+ },+ "422": {+ "description": "Validation Error",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/HTTPValidationError"+ }+ }+ }+ }+ },+ "x-fern-sdk-method-name": "delete_run_tag"+ }+ },+ "/v1/runs/{workflow_run_id}/tags/history": {+ "get": {+ "tags": [+ "Tags"+ ],+ "summary": "Get run tag history",+ "description": "Chronological tag-event log for a workflow run (newest first). Includes SET and DELETE events.",+ "operationId": "get_run_tag_history_v1_runs__workflow_run_id__tags_history_get",+ "parameters": [+ {+ "name": "workflow_run_id",+ "in": "path",+ "required": true,+ "schema": {+ "type": "string",+ "description": "Workflow run ID",+ "examples": [+ "wr_123"+ ],+ "title": "Workflow Run Id"+ },+ "description": "Workflow run ID"+ },+ {+ "name": "limit",+ "in": "query",+ "required": false,+ "schema": {+ "type": "integer",+ "maximum": 500,+ "minimum": 1,+ "description": "Max events to return",+ "default": 100,+ "title": "Limit"+ },+ "description": "Max events to return"+ },+ {+ "name": "since",+ "in": "query",+ "required": false,+ "schema": {+ "anyOf": [+ {+ "type": "string",+ "format": "date-time"+ },+ {+ "type": "null"+ }+ ],+ "description": "Only return events at or after this timestamp",+ "title": "Since"},- "description": "Folder ID"+ "description": "Only return events at or after this timestamp"},{- "name": "delete_workflows",+ "name": "key","in": "query","required": false,"schema": {- "type": "boolean",- "description": "If true, also delete all workflows in this folder",- "default": false,- "title": "Delete Workflows"+ "anyOf": [+ {+ "type": "string"+ },+ {+ "type": "null"+ }+ ],+ "description": "Filter to events for a single tag key",+ "title": "Key"},- "description": "If true, also delete all workflows in this folder"+ "description": "Filter to events for a single tag key"},{"name": "x-api-key",@@ -1344,19 +1690,17 @@],"responses": {"200": {- "description": "Successfully deleted folder",+ "description": "Successfully retrieved tag history","content": {"application/json": {"schema": {- "type": "object",- "additionalProperties": true,- "title": "Response Delete Folder V1 Folders Folder Id Delete"+ "$ref": "#/components/schemas/RunTagHistoryResponse"}}}},"404": {- "description": "Folder not found"+ "description": "Workflow run not found"},"422": {"description": "Validation Error",@@ -1369,7 +1713,7 @@}}},- "x-fern-sdk-method-name": "delete_folder"+ "x-fern-sdk-method-name": "get_run_tag_history"}},"/v1/tag-keys": {@@ -1576,6 +1920,24 @@"description": "List the palette color and current workflow usage count for each grouped tag (key, value) for the organization. The frontend joins these onto tags by (key, value); workflow_count is the number of non-deleted workflows carrying the label and powers the per-label usage and delete blast-radius warnings.","operationId": "list_tag_values_v1_tag_values_get","parameters": [+ {+ "name": "key",+ "in": "query",+ "required": false,+ "schema": {+ "anyOf": [+ {+ "type": "string"+ },+ {+ "type": "null"+ }+ ],+ "description": "Filter to values for a single tag key",+ "title": "Key"+ },+ "description": "Filter to values for a single tag key"+ },{"name": "x-api-key","in": "header",@@ -1994,6 +2356,149 @@"x-fern-sdk-method-name": "batch_get_workflow_tags_post"}},+ "/v1/run-tags": {+ "get": {+ "tags": [+ "Tags"+ ],+ "summary": "Batch get run tags",+ "description": "Batch fetch current tags for many workflow runs. Avoids N+1 on run-list pages.",+ "operationId": "batch_get_run_tags_v1_run_tags_get",+ "parameters": [+ {+ "name": "workflow_run_ids",+ "in": "query",+ "required": false,+ "schema": {+ "anyOf": [+ {+ "type": "string"+ },+ {+ "type": "null"+ }+ ],+ "description": "Comma-separated workflow run IDs",+ "examples": [+ "wr_123,wr_456"+ ],+ "title": "Workflow Run Ids"+ },+ "description": "Comma-separated workflow run IDs"+ },+ {+ "name": "x-api-key",+ "in": "header",+ "required": false,+ "schema": {+ "anyOf": [+ {+ "type": "string"+ },+ {+ "type": "null"+ }+ ],+ "description": "Skyvern API key for authentication. API key can be found at https://app.skyvern.com/settings.",+ "title": "X-Api-Key"+ },+ "description": "Skyvern API key for authentication. API key can be found at https://app.skyvern.com/settings."+ }+ ],+ "responses": {+ "200": {+ "description": "Successfully retrieved tags",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/RunTagsBatchResponse"+ }+ }+ }+ },+ "400": {+ "description": "Too many workflow run IDs requested"+ },+ "422": {+ "description": "Validation Error",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/HTTPValidationError"+ }+ }+ }+ }+ },+ "x-hidden": true,+ "x-fern-sdk-method-name": "batch_get_run_tags"+ },+ "post": {+ "tags": [+ "Tags"+ ],+ "summary": "Batch get run tags (POST)",+ "description": "Batch fetch current tags for many workflow runs (POST variant for id lists exceeding URL length).",+ "operationId": "batch_get_run_tags_post_v1_run_tags_post",+ "parameters": [+ {+ "name": "x-api-key",+ "in": "header",+ "required": false,+ "schema": {+ "anyOf": [+ {+ "type": "string"+ },+ {+ "type": "null"+ }+ ],+ "description": "Skyvern API key for authentication. API key can be found at https://app.skyvern.com/settings.",+ "title": "X-Api-Key"+ },+ "description": "Skyvern API key for authentication. API key can be found at https://app.skyvern.com/settings."+ }+ ],+ "requestBody": {+ "required": true,+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/RunTagsBatchRequest"+ }+ }+ }+ },+ "responses": {+ "200": {+ "description": "Successfully retrieved tags",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/RunTagsBatchResponse"+ }+ }+ }+ },+ "400": {+ "description": "Too many workflow run IDs requested"+ },+ "422": {+ "description": "Validation Error",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/HTTPValidationError"+ }+ }+ }+ }+ },+ "x-hidden": true,+ "x-fern-sdk-method-name": "batch_get_run_tags_post"+ }+ },"/v1/artifacts/{artifact_id}/content": {"get": {"tags": [@@ -5493,10 +5998,8 @@"type": "null"}],- "description": "Skyvern API key for authentication. API key can be found at https://app.skyvern.com/settings.","title": "X-Api-Key"- },- "description": "Skyvern API key for authentication. API key can be found at https://app.skyvern.com/settings."+ }},{"name": "x-max-steps-override",@@ -18522,6 +19025,84 @@],"title": "RunStatus"},+ "RunTagHistoryResponse": {+ "properties": {+ "workflow_run_id": {+ "type": "string",+ "title": "Workflow Run Id"+ },+ "events": {+ "items": {+ "$ref": "#/components/schemas/TagHistoryItem"+ },+ "type": "array",+ "title": "Events"+ }+ },+ "type": "object",+ "required": [+ "workflow_run_id",+ "events"+ ],+ "title": "RunTagHistoryResponse"+ },+ "RunTagsBatchRequest": {+ "properties": {+ "workflow_run_ids": {+ "items": {+ "type": "string"+ },+ "type": "array",+ "title": "Workflow Run Ids",+ "description": "Workflow run IDs to fetch tags for."+ }+ },+ "type": "object",+ "title": "RunTagsBatchRequest",+ "description": "Body for ``POST /v1/run-tags`` (used when the run-id list would exceed\nthe URL length cap)."+ },+ "RunTagsBatchResponse": {+ "properties": {+ "run_tags": {+ "additionalProperties": {+ "items": {+ "$ref": "#/components/schemas/TagItem"+ },+ "type": "array"+ },+ "type": "object",+ "title": "Run Tags"+ }+ },+ "type": "object",+ "required": [+ "run_tags"+ ],+ "title": "RunTagsBatchResponse",+ "description": "Response for the run-tags batch endpoint.\n\nRuns with no tags are present with an empty list so the frontend can\ndistinguish \"fetched, none set\" from \"not fetched\" without a second call.\nRuns outside the caller's org are silently absent (no leakage)."+ },+ "RunTagsResponse": {+ "properties": {+ "workflow_run_id": {+ "type": "string",+ "title": "Workflow Run Id"+ },+ "tags": {+ "items": {+ "$ref": "#/components/schemas/TagResponse"+ },+ "type": "array",+ "title": "Tags"+ }+ },+ "type": "object",+ "required": [+ "workflow_run_id",+ "tags"+ ],+ "title": "RunTagsResponse",+ "description": "Current tags for a workflow run."+ },"RunWebhookReplayResponse": {"properties": {"run_id": {@@ -19698,6 +20279,16 @@"removed_from_workflow_count": {"type": "integer","title": "Removed From Workflow Count"+ },+ "removed_from_run_count": {+ "type": "integer",+ "title": "Removed From Run Count",+ "default": 0+ },+ "removed_count": {+ "type": "integer",+ "title": "Removed Count",+ "default": 0}},"type": "object",@@ -19826,6 +20417,16 @@"removed_from_workflow_count": {"type": "integer","title": "Removed From Workflow Count"+ },+ "removed_from_run_count": {+ "type": "integer",+ "title": "Removed From Run Count",+ "default": 0+ },+ "removed_count": {+ "type": "integer",+ "title": "Removed Count",+ "default": 0}},"type": "object",diff --git a/skyvern-frontend/src/routes/tasks/components/tagging/RunTagPickerCommand.tsx b/skyvern-frontend/src/routes/tasks/components/tagging/RunTagPickerCommand.tsxnew file mode 100644index 000000000..240b1a4cd--- /dev/null+++ b/skyvern-frontend/src/routes/tasks/components/tagging/RunTagPickerCommand.tsx@@ -0,0 +1,76 @@+import { toast } from "@/components/ui/use-toast";+import { TagPickerCommand } from "@/routes/workflows/components/tagging/TagPickerCommand";+import type { Tag, TagKey } from "@/routes/workflows/types/tagTypes";+import { useApplyRunTagsMutation } from "../../hooks/useRunTagMutations";+import * as React from "react";++type Props = {+ workflowRunId: string;+ tagKeys: Array<TagKey>;+ labelSuggestions: Array<string>;+ valueSuggestionsByKey?: Map<string, Array<string>>;+ currentTags?: Array<Tag>;+};++function RunTagPickerCommand({+ workflowRunId,+ tagKeys,+ labelSuggestions,+ valueSuggestionsByKey,+ currentTags,+}: Props) {+ const applyRunTagsMutation = useApplyRunTagsMutation();+ const [tagError, setTagError] = React.useState<string | null>(null);++ function applyTag(tag: Tag) {+ applyRunTagsMutation.mutate(+ {+ workflowRunId,+ data: { tags: [tag] },+ },+ {+ onSuccess: () => {+ const tagLabel =+ tag.key !== null ? `${tag.key}: ${tag.value}` : tag.value;+ toast({ title: `Tagged run with ${tagLabel}.`, variant: "success" });+ },+ },+ );+ }++ function removeTag(tag: Tag) {+ applyRunTagsMutation.mutate(+ {+ workflowRunId,+ data: {+ tags_to_delete: [+ tag.key !== null ? { key: tag.key } : { value: tag.value },+ ],+ },+ },+ {+ onSuccess: () => {+ const tagLabel =+ tag.key !== null ? `${tag.key}: ${tag.value}` : tag.value;+ toast({ title: `Removed ${tagLabel}.`, variant: "success" });+ },+ },+ );+ }++ return (+ <TagPickerCommand+ tagKeys={tagKeys}+ labelSuggestions={labelSuggestions}+ valueSuggestionsByKey={valueSuggestionsByKey}+ currentTags={currentTags}+ onApply={applyTag}+ onRemove={removeTag}+ error={tagError}+ onErrorChange={setTagError}+ disabled={applyRunTagsMutation.isPending}+ />+ );+}++export { RunTagPickerCommand };diff --git a/skyvern-frontend/src/routes/tasks/detail/TaskDetails.runTags.test.tsx b/skyvern-frontend/src/routes/tasks/detail/TaskDetails.runTags.test.tsxnew file mode 100644index 000000000..a91033c9b--- /dev/null+++ b/skyvern-frontend/src/routes/tasks/detail/TaskDetails.runTags.test.tsx@@ -0,0 +1,198 @@+// @vitest-environment jsdom++import type { ReactNode } from "react";+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";+import { fireEvent, render, screen, waitFor } from "@testing-library/react";+import { MemoryRouter } from "react-router-dom";+import {+ afterAll,+ afterEach,+ beforeAll,+ beforeEach,+ describe,+ expect,+ it,+ vi,+} from "vitest";+import { Status, type TaskApiResponse } from "@/api/types";++const { mockGet, mockPost } = vi.hoisted(() => ({+ mockGet: vi.fn(),+ mockPost: vi.fn(),+}));++vi.mock("@/hooks/useCredentialGetter", () => ({+ useCredentialGetter: () => () => Promise.resolve("test-token"),+}));++vi.mock("@/hooks/useApiCredential", () => ({+ useApiCredential: () => "api-key",+}));++vi.mock("@/hooks/useFeatureFlag", () => ({+ useFeatureFlag: () => true,+}));++vi.mock("@/hooks/useFirstParam", () => ({+ useFirstParam: () => "task_1",+}));++vi.mock("@/api/AxiosClient", () => ({+ getClient: () =>+ Promise.resolve({+ get: mockGet,+ post: mockPost,+ }),+}));++vi.mock("@/components/ui/use-toast", () => ({ toast: vi.fn() }));++vi.mock("@/components/ApiWebhookActionsMenu", () => ({+ ApiWebhookActionsMenu: () => <div data-testid="api-menu" />,+}));++vi.mock("@/components/WebhookReplayDialog", () => ({+ WebhookReplayDialog: () => null,+}));++vi.mock("@/routes/workflows/components/tagging/TagChipList", () => ({+ TagChipList: ({+ tags,+ }: {+ tags: Array<{ key: string | null; value: string }>;+ }) => (+ <span data-testid="tag-chip-list">+ {tags.map((tag) => `${tag.key ?? "label"}:${tag.value}`).join(",")}+ </span>+ ),+}));++vi.mock("@/routes/workflows/hooks/useTagKeysQuery", () => ({+ useTagKeysQuery: () => ({ data: [] }),+}));++vi.mock("@/routes/workflows/hooks/useTagValuesQuery", () => ({+ useTagValuesQuery: () => ({ data: new Map() }),+}));++vi.mock("./hooks/useTaskQuery", () => ({+ useTaskQuery: () => ({+ data: {+ task_id: "task_1",+ workflow_run_id: "wr_1",+ status: Status.Completed,+ request: { url: "https://example.test" },+ extracted_information: null,+ failure_reason: null,+ failure_category: null,+ webhook_failure_reason: null,+ max_steps_per_run: null,+ } as TaskApiResponse,+ isLoading: false,+ isError: false,+ }),+}));++vi.mock("../hooks/useRunTagsQuery", () => ({+ useRunTagsQuery: () => ({+ data: [+ { key: "env", value: "prod" },+ { key: null, value: "urgent" },+ ],+ }),+}));++vi.mock("./TaskRunVerificationCodeForm", () => ({+ TaskRunVerificationCodeForm: () => null,+}));++import { TaskDetails } from "./TaskDetails";++class MockResizeObserver {+ observe() {}+ unobserve() {}+ disconnect() {}+}++const originalScrollIntoView = Element.prototype.scrollIntoView;++function wrapper({ children }: { children: ReactNode }) {+ const queryClient = new QueryClient({+ defaultOptions: {+ queries: { retry: false },+ mutations: { retry: false },+ },+ });+ return (+ <QueryClientProvider client={queryClient}>+ <MemoryRouter>{children}</MemoryRouter>+ </QueryClientProvider>+ );+}++beforeAll(() => {+ vi.stubGlobal("ResizeObserver", MockResizeObserver);+ Element.prototype.scrollIntoView = () => {};+});++beforeEach(() => {+ mockGet.mockImplementation((path: string) =>+ Promise.resolve({+ data:+ path === "/workflows/runs/wr_1"+ ? { workflow_id: "wpid_1", workflow_run_id: "wr_1" }+ : { title: "Workflow", workflow_permanent_id: "wpid_1" },+ }),+ );+ mockPost.mockResolvedValue({ data: { workflow_run_id: "wr_1", tags: [] } });+});++afterEach(() => {+ vi.clearAllMocks();+});++afterAll(() => {+ vi.unstubAllGlobals();+ if (originalScrollIntoView) {+ Element.prototype.scrollIntoView = originalScrollIntoView;+ } else {+ delete (Element.prototype as { scrollIntoView?: unknown }).scrollIntoView;+ }+});++describe("TaskDetails run tags", () => {+ it("renders run tags and the tag picker trigger", () => {+ render(<TaskDetails />, { wrapper });++ expect(screen.getByTestId("tag-chip-list").textContent).toContain(+ "env:prod",+ );+ expect(screen.getByRole("button", { name: /tags/i })).not.toBeNull();+ });++ it("removes a current run tag through tags_to_delete", async () => {+ render(<TaskDetails />, { wrapper });++ fireEvent.click(screen.getByRole("button", { name: /tags/i }));+ fireEvent.click(await screen.findByText("env: prod"));++ await waitFor(() =>+ expect(mockPost).toHaveBeenCalledWith("/runs/wr_1/tags", {+ tags_to_delete: [{ key: "env" }],+ }),+ );+ });++ it("removes a current label-only tag through tags_to_delete", async () => {+ render(<TaskDetails />, { wrapper });++ fireEvent.click(screen.getByRole("button", { name: /tags/i }));+ fireEvent.click(await screen.findByText("urgent"));++ await waitFor(() =>+ expect(mockPost).toHaveBeenCalledWith("/runs/wr_1/tags", {+ tags_to_delete: [{ value: "urgent" }],+ }),+ );+ });+});diff --git a/skyvern-frontend/src/routes/tasks/detail/TaskDetails.tsx b/skyvern-frontend/src/routes/tasks/detail/TaskDetails.tsxindex 8d2d6680a..639fe85fa 100644--- a/skyvern-frontend/src/routes/tasks/detail/TaskDetails.tsx+++ b/skyvern-frontend/src/routes/tasks/detail/TaskDetails.tsx@@ -1,6 +1,6 @@import { AxiosError } from "axios";import { getClient } from "@/api/AxiosClient";-import { useState } from "react";+import { useMemo, useState } from "react";import {RunEngine,Status,@@ -12,6 +12,11 @@ import { Status404 } from "@/components/Status404";import { StatusBadge } from "@/components/StatusBadge";import { SwitchBarNavigation } from "@/components/SwitchBarNavigation";import { Button } from "@/components/ui/button";+import {+ Popover,+ PopoverContent,+ PopoverTrigger,+} from "@/components/ui/popover";import {Dialog,DialogClose,@@ -27,13 +32,17 @@ import { Skeleton } from "@/components/ui/skeleton";import { toast } from "@/components/ui/use-toast";import { useApiCredential } from "@/hooks/useApiCredential";import { useCredentialGetter } from "@/hooks/useCredentialGetter";+import { useFeatureFlag } from "@/hooks/useFeatureFlag";import { CodeEditor } from "@/routes/workflows/components/CodeEditor";+import { TagChipList } from "@/routes/workflows/components/tagging/TagChipList";+import { useTagKeysQuery } from "@/routes/workflows/hooks/useTagKeysQuery";+import { useTagValuesQuery } from "@/routes/workflows/hooks/useTagValuesQuery";import { WorkflowApiResponse } from "@/routes/workflows/types/workflowTypes";import { ApiWebhookActionsMenu } from "@/components/ApiWebhookActionsMenu";import { WebhookReplayDialog } from "@/components/WebhookReplayDialog";import { type ApiCommandOptions } from "@/util/apiCommands";import { buildTaskRunPayload } from "@/util/taskRunPayload";-import { PlayIcon, ReloadIcon } from "@radix-ui/react-icons";+import { PlayIcon, ReloadIcon, TokensIcon } from "@radix-ui/react-icons";import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";import { Link, Outlet } from "react-router-dom";import { statusIsFinalized } from "../types";@@ -42,6 +51,11 @@ import { useTaskQuery } from "./hooks/useTaskQuery";import { useFirstParam } from "@/hooks/useFirstParam";import * as env from "@/util/env";import { TaskRunVerificationCodeForm } from "./TaskRunVerificationCodeForm";+import { WORKFLOW_TAGGING_FLAG } from "@/util/featureFlags";+import { useRunTagsQuery } from "../hooks/useRunTagsQuery";+import { RunTagPickerCommand } from "../components/tagging/RunTagPickerCommand";++const EMPTY_LABEL_SUGGESTIONS: Array<string> = [];function createTaskRequestObject(values: TaskApiResponse) {return {@@ -61,6 +75,7 @@ function TaskDetails() {const credentialGetter = useCredentialGetter();const queryClient = useQueryClient();const apiCredential = useApiCredential();+ const taggingEnabled = useFeatureFlag(WORKFLOW_TAGGING_FLAG) !== false;const {data: task,@@ -95,6 +110,23 @@ function TaskDetails() {enabled: !!workflowRun?.workflow_id,});+ const workflowRunId = task?.workflow_run_id ?? null;+ const { data: runTags = [] } = useRunTagsQuery(workflowRunId, {+ enabled: taggingEnabled,+ });+ const { data: tagKeys = [] } = useTagKeysQuery({ enabled: taggingEnabled });+ const tagDescriptions = useMemo(+ () =>+ new Map(+ tagKeys.map((tagKey): [string, string | null] => [+ tagKey.key,+ tagKey.description,+ ]),+ ),+ [tagKeys],+ );+ const { data: tagColors } = useTagValuesQuery({ enabled: taggingEnabled });+const cancelTaskMutation = useMutation({mutationFn: async () => {const client = await getClient(credentialGetter);@@ -207,14 +239,44 @@ function TaskDetails() {<header className="space-y-3"><div className="flex items-center justify-between"><div className="flex items-center gap-5">- <span className="text-3xl">{taskId}</span>- {taskIsLoading ? (- <Skeleton className="h-8 w-32" />- ) : (- task && <StatusBadge status={task.status} />- )}+ <div className="flex min-w-0 flex-col gap-2">+ <div className="flex flex-wrap items-center gap-x-5 gap-y-2">+ <span className="text-3xl">{taskId}</span>+ {taskIsLoading ? (+ <Skeleton className="h-8 w-32" />+ ) : (+ task && <StatusBadge status={task.status} />+ )}+ </div>+ {taggingEnabled && runTags.length > 0 ? (+ <TagChipList+ tags={runTags}+ descriptions={tagDescriptions}+ colors={tagColors}+ maxVisible={6}+ />+ ) : null}+ </div></div><div className="flex items-center gap-2">+ {taggingEnabled && workflowRunId ? (+ <Popover>+ <PopoverTrigger asChild>+ <Button variant="secondary">+ <TokensIcon className="mr-2 h-4 w-4" />+ Tags+ </Button>+ </PopoverTrigger>+ <PopoverContent className="w-72 p-0" align="end">+ <RunTagPickerCommand+ workflowRunId={workflowRunId}+ tagKeys={tagKeys}+ labelSuggestions={EMPTY_LABEL_SUGGESTIONS}+ currentTags={runTags}+ />+ </PopoverContent>+ </Popover>+ ) : null}{/** API & Webhooks consolidated dropdown + controlled dialog */}<ApiWebhookActionsMenugetOptions={() => {diff --git a/skyvern-frontend/src/routes/tasks/hooks/useRunTagMutations.test.tsx b/skyvern-frontend/src/routes/tasks/hooks/useRunTagMutations.test.tsxindex fc11507fa..c8bc2ce9e 100644--- a/skyvern-frontend/src/routes/tasks/hooks/useRunTagMutations.test.tsx+++ b/skyvern-frontend/src/routes/tasks/hooks/useRunTagMutations.test.tsx@@ -5,8 +5,7 @@ import { QueryClient, QueryClientProvider } from "@tanstack/react-query";import { act, renderHook, waitFor } from "@testing-library/react";import { afterEach, describe, expect, it, vi } from "vitest";-const { mockDelete, mockPost } = vi.hoisted(() => ({- mockDelete: vi.fn(),+const { mockPost } = vi.hoisted(() => ({mockPost: vi.fn(),}));@@ -15,15 +14,12 @@ vi.mock("@/hooks/useCredentialGetter", () => ({}));vi.mock("@/api/AxiosClient", () => ({- getClient: () => Promise.resolve({ delete: mockDelete, post: mockPost }),+ getClient: () => Promise.resolve({ post: mockPost }),}));vi.mock("@/components/ui/use-toast", () => ({ toast: vi.fn() }));-import {- useApplyRunTagsMutation,- useDeleteRunTagMutation,-} from "./useRunTagMutations";+import { useApplyRunTagsMutation } from "./useRunTagMutations";function createWrapper() {const queryClient = new QueryClient({@@ -80,27 +76,4 @@ describe("useRunTagMutations", () => {expect(invalidateQueries).toHaveBeenCalledWith({ queryKey: ["runs"] });expect(invalidateQueries).toHaveBeenCalledWith({ queryKey: ["tasks"] });});-- it("deletes a grouped tag by key from the run tag endpoint", async () => {- mockDelete.mockResolvedValue({ data: {} });- const { invalidateQueries, wrapper } = createWrapper();- const { result } = renderHook(() => useDeleteRunTagMutation(), {- wrapper,- });-- act(() => {- result.current.mutate({- workflowRunId: "wr_1",- key: "customer/tier",- });- });-- await waitFor(() => expect(result.current.isSuccess).toBe(true));- expect(mockDelete).toHaveBeenCalledWith("/runs/wr_1/tags/customer%2Ftier");- expect(invalidateQueries).toHaveBeenCalledWith({- queryKey: ["run-tags"],- });- expect(invalidateQueries).toHaveBeenCalledWith({ queryKey: ["runs"] });- expect(invalidateQueries).toHaveBeenCalledWith({ queryKey: ["tasks"] });- });});diff --git a/skyvern-frontend/src/routes/tasks/hooks/useRunTagMutations.ts b/skyvern-frontend/src/routes/tasks/hooks/useRunTagMutations.tsindex 0b77face9..8e5f6373f 100644--- a/skyvern-frontend/src/routes/tasks/hooks/useRunTagMutations.ts+++ b/skyvern-frontend/src/routes/tasks/hooks/useRunTagMutations.ts@@ -42,38 +42,4 @@ function useApplyRunTagsMutation() {});}-function useDeleteRunTagMutation() {- const credentialGetter = useCredentialGetter();- const queryClient = useQueryClient();-- return useMutation({- mutationFn: async ({- workflowRunId,- key,- }: {- workflowRunId: string;- key: string;- }) => {- const client = await getClient(credentialGetter);- return client- .delete(`/runs/${workflowRunId}/tags/${encodeURIComponent(key)}`)- .then((response) => response.data);- },- onSuccess: () => {- queryClient.invalidateQueries({ queryKey: ["run-tags"] });- queryClient.invalidateQueries({ queryKey: ["tag-keys"] });- queryClient.invalidateQueries({ queryKey: ["tag-values"] });- queryClient.invalidateQueries({ queryKey: ["runs"] });- queryClient.invalidateQueries({ queryKey: ["tasks"] });- },- onError: (error: unknown) => {- toast({- variant: "destructive",- title: "Failed to delete run tag",- description: tagErrorMessage(error),- });- },- });-}--export { useApplyRunTagsMutation, useDeleteRunTagMutation };+export { useApplyRunTagsMutation };diff --git a/skyvern-frontend/src/routes/tasks/list/TaskActions.tsx b/skyvern-frontend/src/routes/tasks/list/TaskActions.tsxindex cdfd0ced6..a35026319 100644--- a/skyvern-frontend/src/routes/tasks/list/TaskActions.tsx+++ b/skyvern-frontend/src/routes/tasks/list/TaskActions.tsx@@ -15,6 +15,9 @@ import {DropdownMenuItem,DropdownMenuLabel,DropdownMenuSeparator,+ DropdownMenuSub,+ DropdownMenuSubContent,+ DropdownMenuSubTrigger,DropdownMenuTrigger,} from "@/components/ui/dropdown-menu";import {@@ -30,18 +33,24 @@ import { Input } from "@/components/ui/input";import { Separator } from "@/components/ui/separator";import { Textarea } from "@/components/ui/textarea";import { zodResolver } from "@hookform/resolvers/zod";-import { DotsHorizontalIcon, ReloadIcon } from "@radix-ui/react-icons";+import {+ DotsHorizontalIcon,+ ReloadIcon,+ TokensIcon,+} from "@radix-ui/react-icons";import { useId, useState } from "react";import { useForm } from "react-hook-form";import { useMutation, useQueryClient } from "@tanstack/react-query";import { getClient } from "@/api/AxiosClient";import { useCredentialGetter } from "@/hooks/useCredentialGetter";import { toast } from "@/components/ui/use-toast";+import type { Tag, TagKey } from "@/routes/workflows/types/tagTypes";import {TaskTemplateFormValues,taskTemplateFormSchema,} from "../create/TaskTemplateFormSchema";import { useNavigate } from "react-router-dom";+import { RunTagPickerCommand } from "../components/tagging/RunTagPickerCommand";function createTaskTemplateRequestObject(values: TaskTemplateFormValues,@@ -85,9 +94,21 @@ function createTaskTemplateRequestObject(type Props = {task: TaskApiResponse;+ taggingEnabled?: boolean;+ tagKeys?: Array<TagKey>;+ labelSuggestions?: Array<string>;+ valueSuggestionsByKey?: Map<string, Array<string>>;+ currentTags?: Array<Tag>;};-function TaskActions({ task }: Props) {+function TaskActions({+ task,+ taggingEnabled = false,+ tagKeys = [],+ labelSuggestions = [],+ valueSuggestionsByKey,+ currentTags,+}: Props) {const [open, setOpen] = useState(false);const id = useId();const queryClient = useQueryClient();@@ -138,6 +159,8 @@ function TaskActions({ task }: Props) {mutation.mutate(values);}+ const workflowRunId = task.workflow_run_id;+return (<div className="flex"><Dialog open={open} onOpenChange={setOpen}>@@ -166,6 +189,23 @@ function TaskActions({ task }: Props) {>Rerun Task</DropdownMenuItem>+ {taggingEnabled && workflowRunId ? (+ <DropdownMenuSub>+ <DropdownMenuSubTrigger>+ <TokensIcon className="mr-2 h-4 w-4" />+ Tags+ </DropdownMenuSubTrigger>+ <DropdownMenuSubContent className="w-72 p-0">+ <RunTagPickerCommand+ workflowRunId={workflowRunId}+ tagKeys={tagKeys}+ labelSuggestions={labelSuggestions}+ valueSuggestionsByKey={valueSuggestionsByKey}+ currentTags={currentTags}+ />+ </DropdownMenuSubContent>+ </DropdownMenuSub>+ ) : null}</DropdownMenuContent></DropdownMenu><DialogContent>diff --git a/skyvern-frontend/src/routes/tasks/list/TaskHistory.runTags.test.tsx b/skyvern-frontend/src/routes/tasks/list/TaskHistory.runTags.test.tsxnew file mode 100644index 000000000..84ed6f64d--- /dev/null+++ b/skyvern-frontend/src/routes/tasks/list/TaskHistory.runTags.test.tsx@@ -0,0 +1,109 @@+// @vitest-environment jsdom++import type { ReactNode } from "react";+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";+import { render, screen, waitFor } from "@testing-library/react";+import { MemoryRouter } from "react-router-dom";+import { afterEach, describe, expect, it, vi } from "vitest";+import { Status, type TaskApiResponse } from "@/api/types";++const { mockGet } = vi.hoisted(() => ({ mockGet: vi.fn() }));++vi.mock("@/api/AxiosClient", () => ({+ getClient: () => Promise.resolve({ get: mockGet }),+}));++vi.mock("@/hooks/useCredentialGetter", () => ({+ useCredentialGetter: () => () => Promise.resolve("test-token"),+}));++vi.mock("@/hooks/useFeatureFlag", () => ({+ useFeatureFlag: () => true,+}));++vi.mock("@/components/StatusFilterDropdown", () => ({+ StatusFilterDropdown: () => <div data-testid="status-filter" />,+}));++vi.mock("@/routes/workflows/components/tagging/TagChipList", () => ({+ TagChipList: ({+ tags,+ }: {+ tags: Array<{ key: string | null; value: string }>;+ }) => (+ <span data-testid="tag-chip-list">+ {tags.map((tag) => `${tag.key ?? "label"}:${tag.value}`).join(",")}+ </span>+ ),+}));++vi.mock("@/routes/workflows/hooks/useTagKeysQuery", () => ({+ useTagKeysQuery: () => ({+ data: [{ key: "env", description: "Environment", workflow_count: 1 }],+ }),+}));++vi.mock("@/routes/workflows/hooks/useTagValuesQuery", () => ({+ useTagValuesQuery: () => ({ data: new Map() }),+}));++vi.mock("../hooks/useRunTagsBatchQuery", () => ({+ useRunTagsBatchQuery: () => ({+ data: { wr_1: [{ key: "env", value: "prod" }] },+ isPending: false,+ }),+}));++vi.mock("./TaskActions", () => ({+ TaskActions: ({ taggingEnabled }: { taggingEnabled?: boolean }) => (+ <span data-testid="task-actions-tags">+ {taggingEnabled ? "tags-enabled" : "tags-disabled"}+ </span>+ ),+}));++import { TaskHistory } from "./TaskHistory";++function wrapper({ children }: { children: ReactNode }) {+ const queryClient = new QueryClient({+ defaultOptions: { queries: { retry: false } },+ });+ return (+ <QueryClientProvider client={queryClient}>+ <MemoryRouter>{children}</MemoryRouter>+ </QueryClientProvider>+ );+}++afterEach(() => {+ vi.clearAllMocks();+});++describe("TaskHistory run tags", () => {+ it("renders run tag chips and tag-enabled row actions", async () => {+ mockGet.mockResolvedValue({+ data: [+ {+ task_id: "task_1",+ workflow_run_id: "wr_1",+ status: Status.Completed,+ created_at: "2026-07-08T00:00:00Z",+ request: { url: "https://example.test" },+ failure_reason: null,+ } as TaskApiResponse,+ ],+ });++ render(<TaskHistory />, { wrapper });++ await waitFor(() =>+ expect(mockGet).toHaveBeenCalledWith("/tasks", expect.anything()),+ );+ expect(screen.getByTestId("tag-chip-list").textContent).toContain(+ "env:prod",+ );+ expect(screen.getByTestId("task-actions-tags").textContent).toBe(+ "tags-enabled",+ );+ });+});diff --git a/skyvern-frontend/src/routes/tasks/list/TaskHistory.tsx b/skyvern-frontend/src/routes/tasks/list/TaskHistory.tsxindex ce93d07e5..64d6fed1a 100644--- a/skyvern-frontend/src/routes/tasks/list/TaskHistory.tsx+++ b/skyvern-frontend/src/routes/tasks/list/TaskHistory.tsx@@ -19,16 +19,24 @@ import {TableRow,} from "@/components/ui/table";import { useCredentialGetter } from "@/hooks/useCredentialGetter";+import { useFeatureFlag } from "@/hooks/useFeatureFlag";+import { TagChipList } from "@/routes/workflows/components/tagging/TagChipList";+import { useTagKeysQuery } from "@/routes/workflows/hooks/useTagKeysQuery";+import { useTagValuesQuery } from "@/routes/workflows/hooks/useTagValuesQuery";+import { WORKFLOW_TAGGING_FLAG } from "@/util/featureFlags";import { basicLocalTimeFormat, basicTimeFormat } from "@/util/timeFormat";import { cn } from "@/util/utils";import { useQuery } from "@tanstack/react-query";-import { useState } from "react";+import { useMemo, useState } from "react";import { useNavigate, useSearchParams } from "react-router-dom";import { TaskActions } from "./TaskActions";import { TaskListSkeletonRows } from "./TaskListSkeletonRows";import { Button } from "@/components/ui/button";import { DownloadIcon } from "@radix-ui/react-icons";import { downloadBlob } from "@/util/downloadBlob";+import { useRunTagsBatchQuery } from "../hooks/useRunTagsBatchQuery";++const EMPTY_LABEL_SUGGESTIONS: Array<string> = [];function TaskHistory() {const credentialGetter = useCredentialGetter();@@ -36,6 +44,7 @@ function TaskHistory() {const page = searchParams.get("page") ? Number(searchParams.get("page")) : 1;const navigate = useNavigate();const [statusFilters, setStatusFilters] = useState<Array<Status>>([]);+ const taggingEnabled = useFeatureFlag(WORKFLOW_TAGGING_FLAG) !== false;const {data: tasks,@@ -62,6 +71,31 @@ function TaskHistory() {},});+ const workflowRunIds = useMemo(+ () =>+ (tasks ?? [])+ .map((task) => task.workflow_run_id)+ .filter((id): id is string => Boolean(id)),+ [tasks],+ );+ const { data: runTagsMap = {} } = useRunTagsBatchQuery(workflowRunIds, {+ enabled: taggingEnabled,+ });+ const { data: tagKeys = [] } = useTagKeysQuery({ enabled: taggingEnabled });+ const tagDescriptions = useMemo(+ () =>+ new Map(+ tagKeys.map((tagKey): [string, string | null] => [+ tagKey.key,+ tagKey.description,+ ]),+ ),+ [tagKeys],+ );+ const { data: tagColors } = useTagValuesQuery({ enabled: taggingEnabled });+ const visibleTasks = tasks ?? [];+ const showRowsPending = isPending;+if (isError) {return <div>Error: {error?.message}</div>;}@@ -83,7 +117,7 @@ function TaskHistory() {return; // should never happen}const data = ["id,url,status,created,failure_reason"];- tasks.forEach((task) => {+ visibleTasks.forEach((task) => {const row = [task.task_id,task.request.url,@@ -131,21 +165,35 @@ function TaskHistory() {</TableRow></TableHeader><TableBody>- {isPending ? (+ {showRowsPending ? (<TaskListSkeletonRows />- ) : tasks?.length === 0 ? (+ ) : visibleTasks.length === 0 ? (<TableRow><TableCell colSpan={5}>No tasks found</TableCell></TableRow>) : (- tasks?.map((task) => {+ visibleTasks.map((task) => {+ const workflowRunId = task.workflow_run_id;+ const runTags = workflowRunId+ ? runTagsMap[workflowRunId]+ : undefined;return (<TableRow key={task.task_id}><TableCellclassName="w-1/4 cursor-pointer"onClick={(event) => handleNavigate(event, task.task_id)}>- {task.task_id}+ <div className="flex min-w-0 flex-col gap-1">+ <span>{task.task_id}</span>+ {taggingEnabled && runTags && runTags.length > 0 ? (+ <TagChipList+ tags={runTags}+ descriptions={tagDescriptions}+ colors={tagColors}+ maxVisible={2}+ />+ ) : null}+ </div></TableCell><TableCellclassName="w-1/4 max-w-64 cursor-pointer overflow-hidden overflow-ellipsis whitespace-nowrap"@@ -167,7 +215,13 @@ function TaskHistory() {{basicLocalTimeFormat(task.created_at)}</TableCell><TableCell className="w-1/12">- <TaskActions task={task} />+ <TaskActions+ task={task}+ taggingEnabled={taggingEnabled}+ tagKeys={tagKeys}+ labelSuggestions={EMPTY_LABEL_SUGGESTIONS}+ currentTags={runTags}+ /></TableCell></TableRow>);diff --git a/skyvern-frontend/src/routes/workflows/WorkflowsFlat.tsx b/skyvern-frontend/src/routes/workflows/WorkflowsFlat.tsxindex 034a42252..91c882890 100644--- a/skyvern-frontend/src/routes/workflows/WorkflowsFlat.tsx+++ b/skyvern-frontend/src/routes/workflows/WorkflowsFlat.tsx@@ -967,6 +967,7 @@ function WorkflowsFlat() {tagKeys={tagKeys}labelSuggestions={labelSuggestions}valueSuggestionsByKey={valueSuggestionsByKey}+ currentTags={workflowTags ?? []}taggingEnabled={taggingEnabled}selectedCount={selected.size}onNavigate={(path) => navigate(path)}diff --git a/skyvern-frontend/src/routes/workflows/components/WorkflowRowContextMenu.delete.test.tsx b/skyvern-frontend/src/routes/workflows/components/WorkflowRowContextMenu.delete.test.tsxindex 380795bdb..5b6e10c95 100644--- a/skyvern-frontend/src/routes/workflows/components/WorkflowRowContextMenu.delete.test.tsx+++ b/skyvern-frontend/src/routes/workflows/components/WorkflowRowContextMenu.delete.test.tsx@@ -35,14 +35,15 @@ vi.mock("@/components/ui/context-menu", () => {ContextMenuLabel: Pass,ContextMenuSeparator: () => null,ContextMenuSub: Pass,- ContextMenuSubTrigger: () => null,- ContextMenuSubContent: () => null,+ ContextMenuSubTrigger: Pass,+ ContextMenuSubContent: Pass,};});const deleteWorkflow = vi.fn((opts?: { onSuccess?: () => void }) =>opts?.onSuccess?.(),);+const applyWorkflowTags = vi.fn();vi.mock("../hooks/useWorkflowRowActions", () => ({useWorkflowRowActions: () => ({clone: vi.fn(),@@ -60,7 +61,33 @@ vi.mock("../hooks/useFolderMutations", () => ({useUpdateWorkflowFolderMutation: () => ({ mutateAsync: vi.fn() }),}));vi.mock("../hooks/useWorkflowTagMutations", () => ({- useApplyWorkflowTagsMutation: () => ({ mutate: vi.fn() }),+ useApplyWorkflowTagsMutation: () => ({+ mutate: applyWorkflowTags,+ isPending: false,+ }),+}));+vi.mock("./FolderPickerCommand", () => ({+ FolderPickerCommand: () => null,+}));+vi.mock("./tagging/TagPickerCommand", () => ({+ TagPickerCommand: ({+ currentTags = [],+ onRemove,+ }: {+ currentTags?: Array<{ key: string | null; value: string }>;+ onRemove?: (tag: { key: string | null; value: string }) => void;+ }) => (+ <div data-testid="tag-picker">+ {currentTags.map((tag) => (+ <button+ key={`${tag.key ?? "label"}:${tag.value}`}+ onClick={() => onRemove?.(tag)}+ >+ {tag.key !== null ? `${tag.key}: ${tag.value}` : tag.value}+ </button>+ ))}+ </div>+ ),}));import { WorkflowRowContextMenu } from "./WorkflowRowContextMenu";@@ -78,6 +105,7 @@ function buildWorkflow(): WorkflowApiResponse {function renderMenu(props?: {selectedCount?: number;onDeleted?: (id: string) => void;+ currentTags?: Array<{ key: string | null; value: string }>;}) {return render(<MemoryRouter>@@ -86,6 +114,7 @@ function renderMenu(props?: {tagKeys={[]}labelSuggestions={[]}valueSuggestionsByKey={new Map()}+ currentTags={props?.currentTags}onNavigate={() => {}}selectedCount={props?.selectedCount ?? 1}onDeleted={props?.onDeleted}@@ -96,7 +125,11 @@ function renderMenu(props?: {);}-afterEach(cleanup);+afterEach(() => {+ cleanup();+ deleteWorkflow.mockClear();+ applyWorkflowTags.mockClear();+});describe("WorkflowRowContextMenu single-row delete", () => {it("notifies onDeleted with the workflow id after a successful delete", () => {@@ -109,4 +142,33 @@ describe("WorkflowRowContextMenu single-row delete", () => {expect(onDeleted).toHaveBeenCalledWith("wpid_1");});++ it("removes current tags through the apply mutation tags_to_delete payload", () => {+ renderMenu({+ currentTags: [+ { key: "env", value: "prod" },+ { key: null, value: "urgent" },+ ],+ });++ fireEvent.click(screen.getByRole("button", { name: "env: prod" }));+ fireEvent.click(screen.getByRole("button", { name: "urgent" }));++ expect(applyWorkflowTags).toHaveBeenNthCalledWith(+ 1,+ {+ workflowPermanentId: "wpid_1",+ data: { tags_to_delete: [{ key: "env" }] },+ },+ expect.any(Object),+ );+ expect(applyWorkflowTags).toHaveBeenNthCalledWith(+ 2,+ {+ workflowPermanentId: "wpid_1",+ data: { tags_to_delete: [{ value: "urgent" }] },+ },+ expect.any(Object),+ );+ });});diff --git a/skyvern-frontend/src/routes/workflows/components/WorkflowRowContextMenu.tsx b/skyvern-frontend/src/routes/workflows/components/WorkflowRowContextMenu.tsxindex 5a5b683ee..207f03fa9 100644--- a/skyvern-frontend/src/routes/workflows/components/WorkflowRowContextMenu.tsx+++ b/skyvern-frontend/src/routes/workflows/components/WorkflowRowContextMenu.tsx@@ -49,6 +49,7 @@ type Props = {tagKeys: Array<TagKey>;labelSuggestions: Array<string>;valueSuggestionsByKey?: Map<string, Array<string>>;+ currentTags?: Array<Tag>;onNavigate: (path: string) => void;// Lets the list prune this id from its multi-select set after a single-row// delete, so the selection header/bulk bar can't get stuck on a gone row.@@ -65,6 +66,7 @@ function WorkflowRowContextMenu({tagKeys,labelSuggestions,valueSuggestionsByKey,+ currentTags,onNavigate,onDeleted,selectedCount = 0,@@ -106,6 +108,26 @@ function WorkflowRowContextMenu({);}+ function removeTag(tag: Tag) {+ applyTagsMutation.mutate(+ {+ workflowPermanentId: workflow.workflow_permanent_id,+ data: {+ tags_to_delete: [+ tag.key !== null ? { key: tag.key } : { value: tag.value },+ ],+ },+ },+ {+ onSuccess: () => {+ const tagLabel =+ tag.key !== null ? `${tag.key}: ${tag.value}` : tag.value;+ toast({ title: `Removed ${tagLabel}.`, variant: "success" });+ },+ },+ );+ }+async function moveToFolder(folderId: string | null) {try {await updateFolderMutation.mutateAsync({@@ -210,9 +232,12 @@ function WorkflowRowContextMenu({tagKeys={tagKeys}labelSuggestions={labelSuggestions}valueSuggestionsByKey={valueSuggestionsByKey}+ currentTags={currentTags}error={tagError}onErrorChange={setTagError}+ disabled={applyTagsMutation.isPending}onApply={applyTag}+ onRemove={removeTag}/></ContextMenuSubContent></ContextMenuSub>diff --git a/skyvern-frontend/src/routes/workflows/components/tagging/TagFilterControl.test.tsx b/skyvern-frontend/src/routes/workflows/components/tagging/TagFilterControl.test.tsxindex fb1dc4844..fb3fc2d44 100644--- a/skyvern-frontend/src/routes/workflows/components/tagging/TagFilterControl.test.tsx+++ b/skyvern-frontend/src/routes/workflows/components/tagging/TagFilterControl.test.tsx@@ -25,15 +25,18 @@ function renderControl(props: {exactValuesOnly?: boolean;value?: Array<TagFilterTerm>;onChange?: (terms: Array<TagFilterTerm>) => void;+ tagKeys?: Array<TagKey>;+ onDeleteKey?: (tagKey: TagKey) => void;}) {return render(<MemoryRouter><TagFilterControl- tagKeys={tagKeys}+ tagKeys={props.tagKeys ?? tagKeys}value={props.value ?? []}onChange={props.onChange ?? (() => {})}labelSuggestions={["adhoc"]}exactValuesOnly={props.exactValuesOnly}+ onDeleteKey={props.onDeleteKey}/></MemoryRouter>,);@@ -73,4 +76,32 @@ describe("TagFilterControl default mode", () => {openAndType("prod");expect(screen.getByText(/Filter by label/)).toBeTruthy();});++ it("keeps reserved system groups filterable but hides their delete action", () => {+ const onChange = vi.fn();+ const onDeleteKey = vi.fn();+ renderControl({+ onChange,+ onDeleteKey,+ tagKeys: [+ ...tagKeys,+ {+ key: "skyvern.platform",+ description: null,+ workflow_count: 1,+ },+ ],+ });++ openAndType("skyvern");++ expect(screen.getByText("skyvern.platform")).toBeTruthy();+ expect(screen.queryByLabelText("Delete group skyvern.platform")).toBeNull();++ fireEvent.click(screen.getByText("skyvern.platform"));+ expect(onChange).toHaveBeenCalledWith([+ { key: "skyvern.platform", value: null },+ ]);+ expect(onDeleteKey).not.toHaveBeenCalled();+ });});diff --git a/skyvern-frontend/src/routes/workflows/components/tagging/TagFilterControl.tsx b/skyvern-frontend/src/routes/workflows/components/tagging/TagFilterControl.tsxindex 74ffc7dc8..b91c7a395 100644--- a/skyvern-frontend/src/routes/workflows/components/tagging/TagFilterControl.tsx+++ b/skyvern-frontend/src/routes/workflows/components/tagging/TagFilterControl.tsx@@ -25,6 +25,7 @@ import { copyText } from "@/util/copyText";import { toast } from "@/components/ui/use-toast";import {MAX_AUTOCOMPLETE_SUGGESTIONS,+ isSystemTagKey,parseTagFilterTerm,parseTypedTagQuery,termDedupeKey,@@ -373,7 +374,7 @@ function TagFilterControl({{tagKey.workflow_count}</span>) : null}- {onDeleteKey ? (+ {onDeleteKey && !isSystemTagKey(tagKey.key) ? (<buttontype="button"aria-label={`Delete group ${tagKey.key}`}diff --git a/skyvern-frontend/src/routes/workflows/components/tagging/TagPickerCommand.test.tsx b/skyvern-frontend/src/routes/workflows/components/tagging/TagPickerCommand.test.tsxindex 471af09a5..1d34b5ecc 100644--- a/skyvern-frontend/src/routes/workflows/components/tagging/TagPickerCommand.test.tsx+++ b/skyvern-frontend/src/routes/workflows/components/tagging/TagPickerCommand.test.tsx@@ -109,6 +109,51 @@ describe("TagPickerCommand group-vs-value clarity", () => {});});+describe("TagPickerCommand current-tag toggle", () => {+ it("lists current tags and removes one when selected", () => {+ const onApply = vi.fn();+ const onRemove = vi.fn();+ renderPicker(onApply, {+ currentTags: [+ { key: "env", value: "prod" },+ { key: null, value: "urgent" },+ ],+ onRemove,+ });++ expect(screen.getByText("env: prod")).toBeTruthy();+ fireEvent.click(screen.getByText("urgent"));++ expect(onRemove).toHaveBeenCalledWith({ key: null, value: "urgent" });+ expect(onApply).not.toHaveBeenCalled();+ });++ it("removes a typed tag when it is already current", () => {+ const onApply = vi.fn();+ const onRemove = vi.fn();+ renderPicker(onApply, {+ currentTags: [{ key: null, value: "urgent" }],+ onRemove,+ });++ type("urgent");+ fireEvent.click(screen.getByRole("option", { name: /Remove urgent/i }));++ expect(onRemove).toHaveBeenCalledWith({ key: null, value: "urgent" });+ expect(onApply).not.toHaveBeenCalled();+ });++ it("keeps bulk-style callers add-only when current tags are omitted", () => {+ const onApply = vi.fn();+ renderPicker(onApply);++ type("urgent");+ fireEvent.click(screen.getByRole("option"));++ expect(onApply).toHaveBeenCalledWith({ key: null, value: "urgent" });+ });+});+describe("TagPickerCommand disabled state", () => {it("does not apply a tag while disabled (guards a bulk apply already in flight)", () => {const onApply = vi.fn();@@ -119,4 +164,43 @@ describe("TagPickerCommand disabled state", () => {expect(onApply).not.toHaveBeenCalled();});++ it("does not remove a current tag while disabled", () => {+ const onRemove = vi.fn();+ renderPicker(vi.fn(), {+ currentTags: [{ key: null, value: "urgent" }],+ onRemove,+ disabled: true,+ });++ fireEvent.click(screen.getByText("urgent"));++ expect(onRemove).not.toHaveBeenCalled();+ });+});++describe("TagPickerCommand system tags", () => {+ it("excludes reserved system groups from apply suggestions", () => {+ const onApply = vi.fn();+ renderPicker(onApply, {+ tagKeys: [+ {+ key: "skyvern.platform",+ description: null,+ workflow_count: 1,+ },+ ],+ valueSuggestionsByKey: new Map([["skyvern.platform", ["github"]]]),+ });++ type("skyvern");++ expect(screen.queryByText("skyvern.platform:")).toBeNull();++ type("skyvern.platform:");++ expect(screen.queryByText("github")).toBeNull();+ expect(screen.queryByText(/^Add /)).toBeNull();+ expect(onApply).not.toHaveBeenCalled();+ });});diff --git a/skyvern-frontend/src/routes/workflows/components/tagging/TagPickerCommand.tsx b/skyvern-frontend/src/routes/workflows/components/tagging/TagPickerCommand.tsxindex 763c2b43c..094531174 100644--- a/skyvern-frontend/src/routes/workflows/components/tagging/TagPickerCommand.tsx+++ b/skyvern-frontend/src/routes/workflows/components/tagging/TagPickerCommand.tsx@@ -1,5 +1,5 @@import * as React from "react";-import { PlusIcon } from "@radix-ui/react-icons";+import { CheckIcon, PlusIcon } from "@radix-ui/react-icons";import {Command,CommandEmpty,@@ -12,8 +12,11 @@ import {MAX_AUTOCOMPLETE_SUGGESTIONS,Tag,TagKey,+ isUserWritableTagKey,parseTagInput,parseTypedTagQuery,+ sortTags,+ tagElementKey,validateTag,} from "../../types/tagTypes";@@ -27,6 +30,10 @@ type Props = {// While a bulk apply is in flight, freeze the picker so a second pick can't// start a competing apply for the same selection.disabled?: boolean;+ // Set for single-target pickers (workflow-row and run-tag menus) to enable+ // removal; the bulk Actions surface omits them and stays add-only.+ currentTags?: Array<Tag>;+ onRemove?: (tag: Tag) => void;};// The cmdk body of the tag picker: suggestions plus an "Add label/group:label"@@ -40,6 +47,8 @@ function TagPickerCommand({error,onErrorChange,disabled,+ currentTags,+ onRemove,}: Props) {const [query, setQuery] = React.useState("");const inputRef = React.useRef<HTMLInputElement>(null);@@ -51,10 +60,32 @@ function TagPickerCommand({return () => cancelAnimationFrame(frame);}, []);- function applyTag(tag: Tag) {+ const sortedCurrentTags = React.useMemo(+ () =>+ onRemove+ ? sortTags(+ (currentTags ?? []).filter((tag) => isUserWritableTagKey(tag.key)),+ )+ : [],+ [currentTags, onRemove],+ );+ const currentTagByKey = React.useMemo(() => {+ const byKey = new Map<string, Tag>();+ for (const tag of sortedCurrentTags) {+ byKey.set(tagElementKey(tag), tag);+ }+ return byKey;+ }, [sortedCurrentTags]);++ function selectTag(tag: Tag) {if (disabled) {return;}+ const currentTag = currentTagByKey.get(tagElementKey(tag));+ if (currentTag) {+ onRemove?.(currentTag);+ return;+ }const validationError = validateTag(tag);if (validationError) {onErrorChange?.(validationError);@@ -66,11 +97,18 @@ function TagPickerCommand({const trimmedQuery = query.trim();const normalizedQuery = trimmedQuery.toLowerCase();const candidate = parseTagInput(query);+ const candidateAddable =+ candidate !== null && isUserWritableTagKey(candidate.key);+ const candidateIsCurrent =+ candidate !== null &&+ candidateAddable &&+ currentTagByKey.has(tagElementKey(candidate));const { typedKey, typedValuePartial } = parseTypedTagQuery(trimmedQuery);const groupSuggestions =typedKey === null? tagKeys+ .filter((tk) => isUserWritableTagKey(tk.key)).filter((tk) => tk.key.toLowerCase().includes(normalizedQuery)).slice(0, MAX_AUTOCOMPLETE_SUGGESTIONS): [];@@ -81,13 +119,14 @@ function TagPickerCommand({.slice(0, MAX_AUTOCOMPLETE_SUGGESTIONS): [];const groupedValueMatches =- typedKey !== null+ typedKey !== null && isUserWritableTagKey(typedKey)? (valueSuggestionsByKey?.get(typedKey) ?? []).filter((value) => value.toLowerCase().includes(typedValuePartial)).slice(0, MAX_AUTOCOMPLETE_SUGGESTIONS): [];const hasItems =- candidate !== null ||+ sortedCurrentTags.length > 0 ||+ candidateAddable ||groupSuggestions.length > 0 ||labelMatches.length > 0 ||groupedValueMatches.length > 0;@@ -118,15 +157,36 @@ function TagPickerCommand({</div>) : null}<CommandList>- {candidate !== null && (+ {sortedCurrentTags.length > 0 && (+ <CommandGroup heading="Current">+ {sortedCurrentTags.map((tag) => (+ <CommandItem+ key={tagElementKey(tag)}+ value={`current-${tagElementKey(tag)}`}+ disabled={disabled}+ onSelect={() => selectTag(tag)}+ >+ <span>+ {tag.key !== null ? `${tag.key}: ${tag.value}` : tag.value}+ </span>+ <CheckIcon className="ml-auto h-4 w-4 text-blue-400" />+ </CommandItem>+ ))}+ </CommandGroup>+ )}+ {candidateAddable && candidate !== null && (<CommandGroup><CommandItem- value={`add-${trimmedQuery}`}+ value={`${candidateIsCurrent ? "remove" : "add"}-${trimmedQuery}`}disabled={disabled}- onSelect={() => applyTag(candidate)}+ onSelect={() => selectTag(candidate)}>- <PlusIcon className="mr-2 h-4 w-4" />- Add{" "}+ {candidateIsCurrent ? (+ <CheckIcon className="mr-2 h-4 w-4 text-blue-400" />+ ) : (+ <PlusIcon className="mr-2 h-4 w-4" />+ )}+ {candidateIsCurrent ? "Remove " : "Add "}{candidate.key !== null? `${candidate.key}: ${candidate.value}`: candidate.value}@@ -140,9 +200,14 @@ function TagPickerCommand({key={value}value={`${typedKey}:${value}`}disabled={disabled}- onSelect={() => applyTag({ key: typedKey, value })}+ onSelect={() => selectTag({ key: typedKey, value })}>{value}+ {currentTagByKey.has(+ tagElementKey({ key: typedKey, value }),+ ) ? (+ <CheckIcon className="ml-auto h-4 w-4 text-blue-400" />+ ) : null}</CommandItem>))}</CommandGroup>@@ -168,9 +233,12 @@ function TagPickerCommand({key={value}value={`label-${value}`}disabled={disabled}- onSelect={() => applyTag({ key: null, value })}+ onSelect={() => selectTag({ key: null, value })}>{value}+ {currentTagByKey.has(tagElementKey({ key: null, value })) ? (+ <CheckIcon className="ml-auto h-4 w-4 text-blue-400" />+ ) : null}</CommandItem>))}</CommandGroup>diff --git a/skyvern-frontend/src/routes/workflows/components/tree/WorkflowRow.tsx b/skyvern-frontend/src/routes/workflows/components/tree/WorkflowRow.tsxindex f07b5f412..6047e00f7 100644--- a/skyvern-frontend/src/routes/workflows/components/tree/WorkflowRow.tsx+++ b/skyvern-frontend/src/routes/workflows/components/tree/WorkflowRow.tsx@@ -134,6 +134,7 @@ function WorkflowRow({ workflow, depth = 0 }: WorkflowRowProps) {tagKeys={tagKeys}labelSuggestions={labelSuggestions}valueSuggestionsByKey={valueSuggestionsByKey}+ currentTags={workflowTags ?? []}selectedCount={selectedCount}taggingEnabled={taggingEnabled}onNavigate={(path) => navigate(path)}diff --git a/skyvern-frontend/src/routes/workflows/types/tagTypes.ts b/skyvern-frontend/src/routes/workflows/types/tagTypes.tsindex 822c3a3b0..7cbff90c0 100644--- a/skyvern-frontend/src/routes/workflows/types/tagTypes.ts+++ b/skyvern-frontend/src/routes/workflows/types/tagTypes.ts@@ -83,6 +83,14 @@ export const TAG_KEY_MAX_LENGTH = 64;export const TAG_VALUE_MAX_LENGTH = 256;export const MAX_AUTOCOMPLETE_SUGGESTIONS = 6;+export function isSystemTagKey(key: string | null | undefined): boolean {+ return typeof key === "string" && key.startsWith(RESERVED_TAG_KEY_PREFIX);+}++export function isUserWritableTagKey(key: string | null | undefined): boolean {+ return !isSystemTagKey(key);+}+// Returns an error string when `key` (a group) is invalid, or null when valid.export function validateTagKey(key: string): string | null {const trimmed = key.trim();@@ -92,7 +100,7 @@ export function validateTagKey(key: string): string | null {if (trimmed.length > TAG_KEY_MAX_LENGTH) {return `Group must be at most ${TAG_KEY_MAX_LENGTH} characters.`;}- if (trimmed.startsWith(RESERVED_TAG_KEY_PREFIX)) {+ if (isSystemTagKey(trimmed)) {return `Groups can't start with the reserved "${RESERVED_TAG_KEY_PREFIX}" prefix.`;}if (!TAG_KEY_REGEX.test(trimmed)) {diff --git a/skyvern/forge/sdk/db/models.py b/skyvern/forge/sdk/db/models.pyindex c281f9eef..c37cf515a 100644--- a/skyvern/forge/sdk/db/models.py+++ b/skyvern/forge/sdk/db/models.py@@ -389,7 +389,7 @@ class WorkflowTagEventModel(Base):),CheckConstraint("event_type IN ('set', 'delete')", name="ck_workflow_tag_events_event_type"),CheckConstraint(- "source IN ('manual', 'bulk_apply', 'backfill', 'inherited', 'import')",+ "source IN ('manual', 'bulk_apply', 'backfill', 'inherited', 'import', 'system')",name="ck_workflow_tag_events_source",),CheckConstraint(diff --git a/skyvern/forge/sdk/db/repositories/tags.py b/skyvern/forge/sdk/db/repositories/tags.pyindex 8bf29c499..245d480cb 100644--- a/skyvern/forge/sdk/db/repositories/tags.py+++ b/skyvern/forge/sdk/db/repositories/tags.py@@ -4,6 +4,7 @@ from __future__ import annotationsfrom dataclasses import dataclassfrom datetime import datetime, timezone+from typing import Anyimport structlogfrom sqlalchemy import Exists, and_, exists, func, select, text, update@@ -20,14 +21,23 @@ from skyvern.forge.sdk.db.models import (WorkflowRunTagEventModel,WorkflowTagEventModel,)-from skyvern.forge.sdk.workflow.models.tags import TagEventType, TagWriteContext-from skyvern.forge.sdk.workflow.models.validators import RUN_METADATA_MAX_KEYS, random_tag_color+from skyvern.forge.sdk.workflow.models.tags import CallerType, TagEventType, TagSource, TagWriteContext+from skyvern.forge.sdk.workflow.models.validators import (+ RUN_METADATA_MAX_KEYS,+ is_reserved_tag_key,+ normalize_optional_system_tag_key,+ normalize_tag_value,+ random_tag_color,+)LOG = structlog.get_logger()# Aliased to RUN_METADATA_MAX_KEYS so tag and run_metadata caps stay coupled.MAX_TAGS_PER_WORKFLOW = RUN_METADATA_MAX_KEYSMAX_TAGS_PER_RUN = RUN_METADATA_MAX_KEYS+MAX_SYSTEM_TAGS_PER_WORKFLOW = RUN_METADATA_MAX_KEYS+MAX_SYSTEM_TAGS_PER_RUN = RUN_METADATA_MAX_KEYS+SYSTEM_TAG_CALLER_ID = "system"class TagCountLimitExceeded(ValueError):@@ -61,6 +71,18 @@ class TagValueRenameResult:renamed_workflow_count: int+@dataclass(frozen=True)+class TagDeleteCascadeResult:+ """Exact rows superseded by a registry delete cascade."""++ removed_from_workflow_count: int+ removed_from_run_count: int++ @property+ def removed_count(self) -> int:+ return self.removed_from_workflow_count + self.removed_from_run_count++@dataclass(frozen=True)class TagChange:"""One concrete state change derived from a caller's set/delete request.@@ -72,6 +94,28 @@ class TagChange:superseded_event_id: str | None+def _normalize_required_system_tag_key(key: object) -> str:+ normalized = normalize_optional_system_tag_key(key)+ if normalized is None:+ raise ValueError("system tag keys must be non-empty")+ return normalized+++def _normalize_system_tag_sets(sets: dict[str, str]) -> dict[str, str]:+ normalized: dict[str, str] = {}+ for key, value in sets.items():+ normalized_key = _normalize_required_system_tag_key(key)+ normalized_value = normalize_tag_value(value)+ if normalized_value == "*":+ raise ValueError("system tag values must not be exactly '*'")+ normalized[normalized_key] = normalized_value+ return normalized+++def _normalize_system_tag_deletes(deletes: set[str]) -> set[str]:+ return {_normalize_required_system_tag_key(key) for key in deletes}++class TagsRepository(BaseRepository):"""Database operations for workflow tag events and the tag-key registry."""@@ -104,6 +148,7 @@ class TagsRepository(BaseRepository):label_deletes=label_deletes,colors=colors,max_tags=MAX_TAGS_PER_WORKFLOW,+ max_system_tags=MAX_SYSTEM_TAGS_PER_WORKFLOW,)@db_operation("apply_run_tag_changes")@@ -132,6 +177,47 @@ class TagsRepository(BaseRepository):label_deletes=label_deletes,colors=colors,max_tags=MAX_TAGS_PER_RUN,+ max_system_tags=MAX_SYSTEM_TAGS_PER_RUN,+ )++ @db_operation("apply_system_run_tag_changes")+ async def apply_system_run_tag_changes(+ self,+ workflow_run_id: str,+ organization_id: str,+ sets: dict[str, str],+ caller_id: str = SYSTEM_TAG_CALLER_ID,+ deletes: set[str] | None = None,+ set_at: datetime | None = None,+ ) -> list[TagChange]:+ """Write Skyvern-owned run tags in the reserved namespace.++ Public API schemas reject ``skyvern.*`` keys. Internal writers should use+ this helper so provenance is always ``source=system`` and+ ``caller_type=system``.+ """+ normalized_sets = _normalize_system_tag_sets(sets)+ normalized_deletes = _normalize_system_tag_deletes(deletes or set())+ context = TagWriteContext(+ caller_id=caller_id,+ source=TagSource.SYSTEM,+ caller_type=CallerType.SYSTEM,+ set_at=set_at,+ )+ return await self._apply_tag_changes(+ event_model=WorkflowRunTagEventModel,+ entity_id_name="workflow_run_id",+ entity_id=workflow_run_id,+ entity_label="workflow run",+ organization_id=organization_id,+ sets=normalized_sets,+ deletes=normalized_deletes,+ context=context,+ label_sets=None,+ label_deletes=None,+ colors=None,+ max_tags=MAX_TAGS_PER_RUN,+ max_system_tags=MAX_SYSTEM_TAGS_PER_RUN,)async def _apply_tag_changes(@@ -149,6 +235,7 @@ class TagsRepository(BaseRepository):label_deletes: list[str] | None,colors: dict[str, str] | None,max_tags: int,+ max_system_tags: int,) -> list[TagChange]:label_sets = label_sets or []label_deletes = label_deletes or []@@ -156,11 +243,13 @@ class TagsRepository(BaseRepository):label_set_values = set(label_sets)effective_deletes = {k for k in deletes if k not in sets}effective_label_deletes = {v for v in label_deletes if v not in label_set_values}- if not sets and not effective_deletes and not label_set_values and not effective_label_deletes:+ has_changes = bool(sets or effective_deletes or label_set_values or effective_label_deletes)+ reserved_keys = {key for key in set(sets.keys()) | effective_deletes if is_reserved_tag_key(key)}+ if reserved_keys and context.source != TagSource.SYSTEM:+ raise ValueError("reserved skyvern.* tag keys can only be written with system provenance")+ if event_model is not WorkflowRunTagEventModel and not has_changes:return []- now = datetime.now(timezone.utc)-async with self.Session() as session:if event_model is WorkflowRunTagEventModel:await self._validate_workflow_run_org(@@ -168,6 +257,10 @@ class TagsRepository(BaseRepository):workflow_run_id=entity_id,organization_id=organization_id,)+ if not has_changes:+ return []++ now = context.set_at or datetime.now(timezone.utc)active_rows = await self._get_active_set_rows_for_entity(session,@@ -184,10 +277,18 @@ class TagsRepository(BaseRepository):# partial UNIQUEs catch only same-identity races. Cap is a UX rule.projected_grouped = (set(grouped_current.keys()) | set(sets.keys())) - effective_deletesprojected_labels = (set(label_current.keys()) | label_set_values) - effective_label_deletes- projected_total = len(projected_grouped) + len(projected_labels)- if projected_total > max_tags:+ projected_system_grouped = {key for key in projected_grouped if is_reserved_tag_key(key)}+ projected_user_grouped = projected_grouped - projected_system_grouped+ projected_user_total = len(projected_user_grouped) + len(projected_labels)+ if projected_user_total > max_tags:+ raise TagCountLimitExceeded(+ f"{entity_label} {entity_id} would have {projected_user_total} user-writable tags; "+ f"max is {max_tags}"+ )+ if len(projected_system_grouped) > max_system_tags:raise TagCountLimitExceeded(- f"{entity_label} {entity_id} would have {projected_total} tags; max is {max_tags}"+ f"{entity_label} {entity_id} would have {len(projected_system_grouped)} system tags; "+ f"max is {max_system_tags}")changes: list[TagChange] = []@@ -675,7 +776,7 @@ class TagsRepository(BaseRepository):return list(result.scalars().all())@db_operation("list_tag_values")- async def list_tag_values(self, organization_id: str) -> list[TagValueModel]:+ async def list_tag_values(self, organization_id: str, key: str | None = None) -> list[TagValueModel]:"""Active (key, value, color) registry entries for the org, ordered by keythen value. The frontend joins these onto tags by (key, value) the same wayit joins descriptions onto keys."""@@ -684,8 +785,10 @@ class TagsRepository(BaseRepository):select(TagValueModel).where(TagValueModel.organization_id == organization_id).where(TagValueModel.deleted_at.is_(None))- .order_by(TagValueModel.key.asc(), TagValueModel.value.asc()))+ if key is not None:+ stmt = stmt.where(TagValueModel.key == key)+ stmt = stmt.order_by(TagValueModel.key.asc(), TagValueModel.value.asc())result = await session.execute(stmt)return list(result.scalars().all())@@ -873,6 +976,51 @@ class TagsRepository(BaseRepository):)return (await session.execute(stmt)).scalar_one()+ @db_operation("count_active_workflows_for_key")+ async def count_active_workflows_for_key(self, organization_id: str, key: str) -> int:+ """Number of non-deleted workflows with an active SET on grouped ``key``."""+ async with self.Session() as session:+ stmt = select(func.count(func.distinct(WorkflowTagEventModel.workflow_permanent_id))).where(+ and_(+ WorkflowTagEventModel.organization_id == organization_id,+ WorkflowTagEventModel.key == key,+ WorkflowTagEventModel.superseded_at.is_(None),+ WorkflowTagEventModel.event_type == TagEventType.SET.value,+ WorkflowTagEventModel.deleted_at.is_(None),+ self._non_deleted_workflow_exists(organization_id),+ )+ )+ return (await session.execute(stmt)).scalar_one()++ @db_operation("count_active_runs_for_key")+ async def count_active_runs_for_key(self, organization_id: str, key: str) -> int:+ """Number of workflow runs with an active SET on grouped ``key``."""+ async with self.Session() as session:+ stmt = select(func.count(func.distinct(WorkflowRunTagEventModel.workflow_run_id))).where(+ and_(+ WorkflowRunTagEventModel.organization_id == organization_id,+ WorkflowRunTagEventModel.key == key,+ WorkflowRunTagEventModel.superseded_at.is_(None),+ WorkflowRunTagEventModel.event_type == TagEventType.SET.value,+ )+ )+ return (await session.execute(stmt)).scalar_one()++ @db_operation("count_active_runs_for_value")+ async def count_active_runs_for_value(self, organization_id: str, key: str, value: str) -> int:+ """Number of workflow runs with an active SET on grouped ``(key, value)``."""+ async with self.Session() as session:+ stmt = select(func.count(func.distinct(WorkflowRunTagEventModel.workflow_run_id))).where(+ and_(+ WorkflowRunTagEventModel.organization_id == organization_id,+ WorkflowRunTagEventModel.key == key,+ WorkflowRunTagEventModel.value == value,+ WorkflowRunTagEventModel.superseded_at.is_(None),+ WorkflowRunTagEventModel.event_type == TagEventType.SET.value,+ )+ )+ return (await session.execute(stmt)).scalar_one()+async def _soft_delete_tag_value_rows(self,session: AsyncSession,@@ -904,6 +1052,7 @@ class TagsRepository(BaseRepository):organization_id: str,key: str,value: str | None = None,+ soft_delete_column: Any | None = None,) -> list[WorkflowTagEventModel] | list[WorkflowRunTagEventModel]:filters = [event_model.organization_id == organization_id,@@ -913,9 +1062,8 @@ class TagsRepository(BaseRepository):]if value is not None:filters.append(event_model.value == value)- deleted_at = getattr(event_model, "deleted_at", None)- if deleted_at is not None:- filters.append(deleted_at.is_(None))+ if soft_delete_column is not None:+ filters.append(soft_delete_column.is_(None))result = await session.execute(select(event_model).where(and_(*filters)))return list(result.scalars().all())@@ -956,11 +1104,11 @@ class TagsRepository(BaseRepository):organization_id: str,key: str,context: TagWriteContext,- ) -> int | None:+ ) -> TagDeleteCascadeResult | None:"""Cascade-delete a tag key: write a DELETE event for every workflow thatcurrently has it, then soft-delete the key registry row and its value color- rows (so GET /tag-values stops returning colors for the removed key). Returns the number- of workflows the tag was removed from, or None when the key is not+ rows (so GET /tag-values stops returning colors for the removed key). Returns exact workflow/run+ counts removed by the transaction, or None when the key is notregistered (caller should 404). Idempotent: a second call returns None.DELETE events don't match the SET-only partial UNIQUE, so superseding the@@ -1002,6 +1150,7 @@ class TagsRepository(BaseRepository):event_model=WorkflowTagEventModel,organization_id=organization_id,key=key,+ soft_delete_column=WorkflowTagEventModel.deleted_at,)active_run_sets = await self._get_active_grouped_set_rows(session,@@ -1038,7 +1187,10 @@ class TagsRepository(BaseRepository):key_row.deleted_at = nowawait self._soft_delete_tag_value_rows(session, organization_id=organization_id, key=key, now=now)await session.commit()- return len(active_sets)+ return TagDeleteCascadeResult(+ removed_from_workflow_count=len(active_sets),+ removed_from_run_count=len(active_run_sets),+ )@db_operation("delete_tag_value")async def delete_tag_value(@@ -1047,12 +1199,12 @@ class TagsRepository(BaseRepository):key: str,value: str,context: TagWriteContext,- ) -> int | None:+ ) -> TagDeleteCascadeResult | None:"""Cascade-delete a single grouped label ``(key, value)``, mirroring``delete_tag_key`` at value granularity: write a DELETE event (carrying thevalue, so history records which label was removed) for every workflow with- an active SET on it, then soft-delete the ``(key, value)`` color row. Returns- the number of workflows the label was removed from, or None when neither a+ an active SET on it, then soft-delete the ``(key, value)`` color row. Returns exact+ workflow/run counts removed by the transaction, or None when neither aregistered color row nor an active SET exists (caller should 404). Idempotent:a second call returns None; re-applying via a SET re-registers the label.@@ -1080,6 +1232,7 @@ class TagsRepository(BaseRepository):organization_id=organization_id,key=key,value=value,+ soft_delete_column=WorkflowTagEventModel.deleted_at,)active_run_sets = await self._get_active_grouped_set_rows(session,@@ -1121,7 +1274,10 @@ class TagsRepository(BaseRepository):session, organization_id=organization_id, key=key, now=now, value=value)await session.commit()- return len(active_sets)+ return TagDeleteCascadeResult(+ removed_from_workflow_count=len(active_sets),+ removed_from_run_count=len(active_run_sets),+ )@db_operation("rename_tag_value")async def rename_tag_value(diff --git a/skyvern/forge/sdk/db/tag_filters.py b/skyvern/forge/sdk/db/tag_filters.pyindex c313d221d..1281bce09 100644--- a/skyvern/forge/sdk/db/tag_filters.py+++ b/skyvern/forge/sdk/db/tag_filters.py@@ -1,29 +1,36 @@-from typing import Any+from collections.abc import Sequence+from typing import Any, Protocolfrom sqlalchemy import and_, selectfrom sqlalchemy.sql.elements import ColumnElement-from skyvern.forge.sdk.db.models import WorkflowTagEventModel+from skyvern.forge.sdk.db.models import WorkflowRunTagEventModel, WorkflowTagEventModelfrom skyvern.forge.sdk.workflow.models.tags import TagEventType-def workflow_tag_wpid_subqueries(- workflow_tag_filter: list[tuple[str | None, str | None]] | None,+class _TagEventModel(Protocol):+ organization_id: Any+ key: Any+ value: Any+ event_type: Any+ superseded_at: Any+++def _tag_event_entity_subqueries(+ *,+ event_model: type[_TagEventModel],+ entity_column: Any,+ tag_filter: Sequence[tuple[str | None, str | None]] | None,organization_id: str | None = None,+ soft_delete_column: Any | None = None,) -> list[Any]:- """One scalar ``workflow_permanent_id`` subquery per term from ``WorkflowTagEventModel``.-- Shared by the analytics summary filter and the workflows-list filter: exact ``(key, value)``- (OR within a key), group-only ``(key, None)``, and label-only ``(None, value)``, AND-ed across- distinct terms. Shape semantics are exercised in ``tests/unit/test_workflows_list_tag_filter.py``- and ``tests/cloud/test_analytics_workflow_tag_filter.py``."""- if not workflow_tag_filter:+ if not tag_filter:return []exact_values_by_key: dict[str, list[str]] = {}key_only_terms: list[str] = []value_only_terms: list[str] = []- for key, value in workflow_tag_filter:+ for key, value in tag_filter:if key is not None and value is not None:exact_values_by_key.setdefault(key, []).append(value)elif key is not None:@@ -33,26 +40,55 @@ def workflow_tag_wpid_subqueries(def _base_filters() -> list[ColumnElement[bool]]:filters: list[ColumnElement[bool]] = [- WorkflowTagEventModel.deleted_at.is_(None),- WorkflowTagEventModel.superseded_at.is_(None),- WorkflowTagEventModel.event_type == TagEventType.SET.value,+ event_model.superseded_at.is_(None),+ event_model.event_type == TagEventType.SET.value,]+ if soft_delete_column is not None:+ filters.append(soft_delete_column.is_(None))if organization_id is not None:- filters.append(WorkflowTagEventModel.organization_id == organization_id)+ filters.append(event_model.organization_id == organization_id)return filtersdef _subquery(*term_filters: ColumnElement[bool]) -> Any:- return (- select(WorkflowTagEventModel.workflow_permanent_id)- .where(and_(*_base_filters(), *term_filters))- .scalar_subquery()- )+ return select(entity_column).where(and_(*_base_filters(), *term_filters)).scalar_subquery()subqueries: list[Any] = []for key, values in exact_values_by_key.items():- subqueries.append(_subquery(WorkflowTagEventModel.key == key, WorkflowTagEventModel.value.in_(values)))+ subqueries.append(_subquery(event_model.key == key, event_model.value.in_(values)))for key in key_only_terms:- subqueries.append(_subquery(WorkflowTagEventModel.key == key))+ subqueries.append(_subquery(event_model.key == key))for value in value_only_terms:- subqueries.append(_subquery(WorkflowTagEventModel.value == value))+ subqueries.append(_subquery(event_model.value == value))return subqueries+++def workflow_tag_wpid_subqueries(+ workflow_tag_filter: Sequence[tuple[str | None, str | None]] | None,+ organization_id: str | None = None,+) -> list[Any]:+ """One scalar ``workflow_permanent_id`` subquery per term from ``WorkflowTagEventModel``.++ Shared by the analytics summary filter and the workflows-list filter: exact ``(key, value)``+ (OR within a key), group-only ``(key, None)``, and label-only ``(None, value)``, AND-ed across+ distinct terms. Shape semantics are exercised in ``tests/unit/test_workflows_list_tag_filter.py``+ and ``tests/cloud/test_analytics_workflow_tag_filter.py``."""+ return _tag_event_entity_subqueries(+ event_model=WorkflowTagEventModel,+ entity_column=WorkflowTagEventModel.workflow_permanent_id,+ tag_filter=workflow_tag_filter,+ organization_id=organization_id,+ soft_delete_column=WorkflowTagEventModel.deleted_at,+ )+++def run_tag_run_id_subqueries(+ run_tag_filter: Sequence[tuple[str | None, str | None]] | None,+ organization_id: str | None = None,+) -> list[Any]:+ """One scalar ``workflow_run_id`` subquery per term from ``WorkflowRunTagEventModel``."""+ return _tag_event_entity_subqueries(+ event_model=WorkflowRunTagEventModel,+ entity_column=WorkflowRunTagEventModel.workflow_run_id,+ tag_filter=run_tag_filter,+ organization_id=organization_id,+ )diff --git a/skyvern/forge/sdk/routes/agent_protocol.py b/skyvern/forge/sdk/routes/agent_protocol.pyindex 4ad79b3c4..cc48556e2 100644--- a/skyvern/forge/sdk/routes/agent_protocol.py+++ b/skyvern/forge/sdk/routes/agent_protocol.py@@ -56,7 +56,11 @@ from skyvern.forge.sdk.core.curl_converter import curl_to_http_request_block_parfrom skyvern.forge.sdk.core.permissions.permission_checker_factory import PermissionCheckerFactoryfrom skyvern.forge.sdk.core.security import generate_skyvern_signaturefrom skyvern.forge.sdk.db.enums import OrganizationAuthTokenType-from skyvern.forge.sdk.db.repositories.tags import TagValueRenameCollision, TagValueRenameResult+from skyvern.forge.sdk.db.repositories.tags import (+ RunTagWorkflowRunMismatch,+ TagValueRenameCollision,+ TagValueRenameResult,+)from skyvern.forge.sdk.enterprise_features import collect_enterprise_gated_run_featuresfrom skyvern.forge.sdk.executor.factory import AsyncExecutorFactoryfrom skyvern.forge.sdk.models import Step@@ -119,6 +123,7 @@ from skyvern.forge.sdk.workflow.exceptions import (WorkflowDefinitionValidationException,)from skyvern.forge.sdk.workflow.models.tags import TagSource, TagWriteContext+from skyvern.forge.sdk.workflow.models.validators import is_reserved_tag_keyfrom skyvern.forge.sdk.workflow.models.workflow import (RunWorkflowResponse,Workflow,@@ -149,6 +154,10 @@ from skyvern.schemas.runs import (WorkflowRunResponse,)from skyvern.schemas.tags import (+ RunTagHistoryResponse,+ RunTagsBatchRequest,+ RunTagsBatchResponse,+ RunTagsResponse,TagApplyRequest,TagHistoryItem,TagHistoryResponse,@@ -483,6 +492,14 @@ def _workflow_run_request_to_legacy_request(workflow_run_request: WorkflowRunReq)+def _tag_write_context_from_caller(caller: org_auth_service.CallerContext) -> TagWriteContext:+ return TagWriteContext(+ caller_id=caller.caller_id,+ source=TagSource.MANUAL,+ caller_type=caller.caller_type,+ )++@base_router.post("/run/agents",tags=["Runs"],@@ -513,13 +530,14 @@ async def run_workflow(request: Request,background_tasks: BackgroundTasks,workflow_run_request: WorkflowRunRequest,- current_org: Organization = Depends(org_auth_service.get_current_org),+ caller: org_auth_service.CallerContext = Depends(org_auth_service.get_current_caller_context),template: bool = Query(False),x_api_key: Annotated[str | None, Header()] = None,x_max_steps_override: Annotated[int | None, Header()] = None,x_user_agent: Annotated[str | None, Header()] = None,) -> WorkflowRunResponse:analytics.capture("skyvern-oss-run-workflow")+ current_org = caller.organizationawait PermissionCheckerFactory.get_instance().check(current_org, browser_session_id=workflow_run_request.browser_session_id)@@ -543,6 +561,7 @@ async def run_workflow(request=request,background_tasks=background_tasks,trigger_type=trigger_type,+ tag_write_context=_tag_write_context_from_caller(caller),)except MissingBrowserAddressError as e:raise HTTPException(status_code=400, detail=str(e)) from e@@ -1557,6 +1576,18 @@ async def _assert_workflow_in_org(workflow_permanent_id: str, organization_id: s)+async def _assert_workflow_run_in_org(workflow_run_id: str, organization_id: str) -> None:+ workflow_run = await app.DATABASE.workflow_runs.get_workflow_run(+ workflow_run_id=workflow_run_id,+ organization_id=organization_id,+ )+ if workflow_run is None:+ raise HTTPException(+ status_code=http_status.HTTP_404_NOT_FOUND,+ detail=f"Workflow run {workflow_run_id} not found",+ )++def _tag_event_to_response(row: Any) -> TagResponse:return TagResponse(key=row.key, value=row.value, source=row.source, set_at=row.set_at, set_by=row.set_by)@@ -1608,6 +1639,47 @@ async def _apply_tag_changes_with_retry()+async def _apply_run_tag_changes_with_retry(+ *,+ workflow_run_id: str,+ organization_id: str,+ sets: dict[str, str],+ deletes: set[str],+ context: TagWriteContext,+ label_sets: list[str] | None = None,+ label_deletes: list[str] | None = None,+ colors: dict[str, str] | None = None,+) -> None:+ """Wrap ``apply_run_tag_changes`` with the same concurrency behavior as+ workflow tags. Org-mismatch is mapped to the route-level 404 contract."""+ for attempt in range(2):+ try:+ await app.DATABASE.tags.apply_run_tag_changes(+ workflow_run_id=workflow_run_id,+ organization_id=organization_id,+ sets=sets,+ deletes=deletes,+ context=context,+ label_sets=label_sets,+ label_deletes=label_deletes,+ colors=colors,+ )+ return+ except RunTagWorkflowRunMismatch as e:+ raise HTTPException(+ status_code=http_status.HTTP_404_NOT_FOUND,+ detail=f"Workflow run {workflow_run_id} not found",+ ) from e+ except IntegrityError:+ if attempt == 0:+ await asyncio.sleep(random.uniform(0.01, 0.05))+ continue+ raise HTTPException(+ status_code=http_status.HTTP_409_CONFLICT,+ detail="Tag write conflicted with a concurrent update; please retry",+ )++async def _rename_tag_value_with_retry(*,organization_id: str,@@ -1685,11 +1757,7 @@ async def apply_workflow_tags(organization_id = caller.organization.organization_idawait _assert_workflow_in_org(workflow_permanent_id, organization_id)- write_ctx = TagWriteContext(- caller_id=caller.caller_id,- source=TagSource.MANUAL,- caller_type=caller.caller_type,- )+ write_ctx = _tag_write_context_from_caller(caller)# A tag's key is its group; grouped tags are keyed (last-wins per group),# standalone labels (no key) are addressed by value.grouped_sets: dict[str, str] = {tag.key: tag.value for tag in data.tags if tag.key is not None}@@ -1746,11 +1814,7 @@ async def delete_workflow_tag(_validate_path_key(key)await _assert_workflow_in_org(workflow_permanent_id, organization_id)- write_ctx = TagWriteContext(- caller_id=caller.caller_id,- source=TagSource.MANUAL,- caller_type=caller.caller_type,- )+ write_ctx = _tag_write_context_from_caller(caller)await _apply_tag_changes_with_retry(workflow_permanent_id=workflow_permanent_id,organization_id=organization_id,@@ -1857,6 +1921,190 @@ async def get_workflow_tag_history()+@legacy_base_router.post(+ "/runs/{workflow_run_id}/tags",+ response_model=RunTagsResponse,+ tags=["agent"],+ include_in_schema=False,+)+@legacy_base_router.post("/runs/{workflow_run_id}/tags/", response_model=RunTagsResponse, include_in_schema=False)+@base_router.post(+ "/runs/{workflow_run_id}/tags",+ response_model=RunTagsResponse,+ tags=["Tags"],+ openapi_extra={"x-fern-sdk-method-name": "apply_run_tags"},+ description="Atomically apply tag changes to a workflow run. Sets and deletes happen in one transaction; "+ "same-key collisions resolve set-wins.",+ summary="Apply run tags",+ responses={+ 200: {"description": "Successfully applied tag changes"},+ 404: {"description": "Workflow run not found"},+ 422: {"description": "Invalid tag key or value"},+ },+)+@base_router.post("/runs/{workflow_run_id}/tags/", response_model=RunTagsResponse, include_in_schema=False)+async def apply_run_tags(+ workflow_run_id: str = Path(..., description="Workflow run ID", examples=["wr_123"]),+ data: TagApplyRequest = Body(...),+ caller: org_auth_service.CallerContext = Depends(org_auth_service.get_current_caller_context),+ _tagging_gate: None = Depends(require_workflow_tagging),+) -> RunTagsResponse:+ analytics.capture("skyvern-oss-run-tags-apply")+ organization_id = caller.organization.organization_id++ write_ctx = _tag_write_context_from_caller(caller)+ grouped_sets: dict[str, str] = {tag.key: tag.value for tag in data.tags if tag.key is not None}+ label_sets: list[str] = [tag.value for tag in data.tags if tag.key is None]+ grouped_deletes: set[str] = {d.key for d in data.tags_to_delete if d.key is not None}+ label_deletes: list[str] = [d.value for d in data.tags_to_delete if d.key is None and d.value is not None]+ try:+ await _apply_run_tag_changes_with_retry(+ workflow_run_id=workflow_run_id,+ organization_id=organization_id,+ sets=grouped_sets,+ deletes=grouped_deletes,+ context=write_ctx,+ label_sets=label_sets,+ label_deletes=label_deletes,+ colors=data.colors,+ )+ except ValueError as e:+ raise HTTPException(status_code=http_status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(e)) from e++ return await _build_run_tags_response(workflow_run_id, organization_id)+++@legacy_base_router.delete(+ "/runs/{workflow_run_id}/tags/{key}",+ tags=["agent"],+ include_in_schema=False,+)+@legacy_base_router.delete("/runs/{workflow_run_id}/tags/{key}/", include_in_schema=False)+@base_router.delete(+ "/runs/{workflow_run_id}/tags/{key}",+ response_model=RunTagsResponse,+ tags=["Tags"],+ openapi_extra={"x-fern-sdk-method-name": "delete_run_tag"},+ description="Soft-delete a single grouped tag from a workflow run. Writes a DELETE event row.",+ summary="Delete run tag",+ responses={+ 200: {"description": "Successfully deleted tag (or no-op if absent)"},+ 404: {"description": "Workflow run not found"},+ },+)+@base_router.delete("/runs/{workflow_run_id}/tags/{key}/", response_model=RunTagsResponse, include_in_schema=False)+async def delete_run_tag(+ workflow_run_id: str = Path(..., description="Workflow run ID", examples=["wr_123"]),+ key: str = Path(..., description="Tag key to delete", examples=["env"]),+ caller: org_auth_service.CallerContext = Depends(org_auth_service.get_current_caller_context),+ _tagging_gate: None = Depends(require_workflow_tagging),+) -> RunTagsResponse:+ analytics.capture("skyvern-oss-run-tags-delete")+ organization_id = caller.organization.organization_id+ _validate_path_key(key)++ write_ctx = _tag_write_context_from_caller(caller)+ await _apply_run_tag_changes_with_retry(+ workflow_run_id=workflow_run_id,+ organization_id=organization_id,+ sets={},+ deletes={key},+ context=write_ctx,+ )+ return await _build_run_tags_response(workflow_run_id, organization_id)+++@legacy_base_router.get(+ "/runs/{workflow_run_id}/tags",+ response_model=RunTagsResponse,+ tags=["agent"],+ include_in_schema=False,+)+@legacy_base_router.get("/runs/{workflow_run_id}/tags/", response_model=RunTagsResponse, include_in_schema=False)+@base_router.get(+ "/runs/{workflow_run_id}/tags",+ response_model=RunTagsResponse,+ tags=["Tags"],+ openapi_extra={"x-fern-sdk-method-name": "get_run_tags"},+ description="Get the current tag state for a workflow run.",+ summary="Get run tags",+ responses={+ 200: {"description": "Successfully retrieved tags"},+ 404: {"description": "Workflow run not found"},+ },+)+@base_router.get("/runs/{workflow_run_id}/tags/", response_model=RunTagsResponse, include_in_schema=False)+async def get_run_tags(+ workflow_run_id: str = Path(..., description="Workflow run ID", examples=["wr_123"]),+ current_org: Organization = Depends(org_auth_service.get_current_org),+ _tagging_gate: None = Depends(require_workflow_tagging),+) -> RunTagsResponse:+ organization_id = current_org.organization_id+ await _assert_workflow_run_in_org(workflow_run_id, organization_id)+ return await _build_run_tags_response(workflow_run_id, organization_id)+++async def _build_run_tags_response(workflow_run_id: str, organization_id: str) -> RunTagsResponse:+ rows = await app.DATABASE.tags.get_active_tag_events_for_run(+ workflow_run_id=workflow_run_id,+ organization_id=organization_id,+ )+ tags = [_tag_event_to_response(row) for row in rows if row.value is not None]+ tags.sort(key=lambda t: (t.key is not None, t.key or "", t.value))+ return RunTagsResponse(workflow_run_id=workflow_run_id, tags=tags)+++@legacy_base_router.get(+ "/runs/{workflow_run_id}/tags/history",+ response_model=RunTagHistoryResponse,+ tags=["agent"],+ include_in_schema=False,+)+@legacy_base_router.get(+ "/runs/{workflow_run_id}/tags/history/",+ response_model=RunTagHistoryResponse,+ include_in_schema=False,+)+@base_router.get(+ "/runs/{workflow_run_id}/tags/history",+ response_model=RunTagHistoryResponse,+ tags=["Tags"],+ openapi_extra={"x-fern-sdk-method-name": "get_run_tag_history"},+ description="Chronological tag-event log for a workflow run (newest first). Includes SET and DELETE events.",+ summary="Get run tag history",+ responses={+ 200: {"description": "Successfully retrieved tag history"},+ 404: {"description": "Workflow run not found"},+ },+)+@base_router.get(+ "/runs/{workflow_run_id}/tags/history/",+ response_model=RunTagHistoryResponse,+ include_in_schema=False,+)+async def get_run_tag_history(+ workflow_run_id: str = Path(..., description="Workflow run ID", examples=["wr_123"]),+ limit: int = Query(100, ge=1, le=500, description="Max events to return"),+ since: datetime | None = Query(None, description="Only return events at or after this timestamp"),+ key: str | None = Query(None, description="Filter to events for a single tag key"),+ current_org: Organization = Depends(org_auth_service.get_current_org),+ _tagging_gate: None = Depends(require_workflow_tagging),+) -> RunTagHistoryResponse:+ organization_id = current_org.organization_id+ await _assert_workflow_run_in_org(workflow_run_id, organization_id)+ rows = await app.DATABASE.tags.get_run_tag_event_history(+ workflow_run_id=workflow_run_id,+ organization_id=organization_id,+ limit=limit,+ since=since,+ key=key,+ )+ return RunTagHistoryResponse(+ workflow_run_id=workflow_run_id,+ events=[TagHistoryItem.model_validate(r) for r in rows],+ )++@legacy_base_router.get("/tag-keys", response_model=list[TagKey], tags=["agent"], include_in_schema=False)@legacy_base_router.get("/tag-keys/", response_model=list[TagKey], include_in_schema=False)@base_router.get(@@ -1939,19 +2187,21 @@ async def delete_tag_key() -> TagKeyDeleteResponse:analytics.capture("skyvern-oss-tag-key-delete")_validate_path_key(key)- context = TagWriteContext(- caller_id=caller.caller_id,- source=TagSource.MANUAL,- caller_type=caller.caller_type,- )- removed_count = await app.DATABASE.tags.delete_tag_key(- organization_id=caller.organization.organization_id,+ context = _tag_write_context_from_caller(caller)+ organization_id = caller.organization.organization_id+ delete_result = await app.DATABASE.tags.delete_tag_key(+ organization_id=organization_id,key=key,context=context,)- if removed_count is None:+ if delete_result is None:raise HTTPException(status_code=http_status.HTTP_404_NOT_FOUND, detail=f"Tag key '{key}' not found")- return TagKeyDeleteResponse(key=key, removed_from_workflow_count=removed_count)+ return TagKeyDeleteResponse(+ key=key,+ removed_from_workflow_count=delete_result.removed_from_workflow_count,+ removed_from_run_count=delete_result.removed_from_run_count,+ removed_count=delete_result.removed_count,+ )@legacy_base_router.get("/tag-values", response_model=list[TagValue], tags=["agent"], include_in_schema=False)@@ -1969,11 +2219,12 @@ async def delete_tag_key()@base_router.get("/tag-values/", response_model=list[TagValue], include_in_schema=False)async def list_tag_values(+ key: str | None = Query(None, description="Filter to values for a single tag key"),current_org: Organization = Depends(org_auth_service.get_current_org),_tagging_gate: None = Depends(require_workflow_tagging),) -> list[TagValue]:organization_id = current_org.organization_id- rows = await app.DATABASE.tags.list_tag_values(organization_id=organization_id)+ rows = await app.DATABASE.tags.list_tag_values(organization_id=organization_id, key=key)counts = await app.DATABASE.tags.count_active_workflows_per_value(organization_id=organization_id)return [TagValue(@@ -2055,11 +2306,7 @@ async def rename_tag_value() -> TagValueRenameResponse:analytics.capture("skyvern-oss-tag-value-rename")_validate_path_key(key)- context = TagWriteContext(- caller_id=caller.caller_id,- source=TagSource.MANUAL,- caller_type=caller.caller_type,- )+ context = _tag_write_context_from_caller(caller)try:result = await _rename_tag_value_with_retry(organization_id=caller.organization.organization_id,@@ -2108,28 +2355,32 @@ async def delete_tag_value() -> TagValueDeleteResponse:analytics.capture("skyvern-oss-tag-value-delete")_validate_path_key(key)- context = TagWriteContext(- caller_id=caller.caller_id,- source=TagSource.MANUAL,- caller_type=caller.caller_type,- )- removed_count = await app.DATABASE.tags.delete_tag_value(- organization_id=caller.organization.organization_id,+ context = _tag_write_context_from_caller(caller)+ organization_id = caller.organization.organization_id+ delete_result = await app.DATABASE.tags.delete_tag_value(+ organization_id=organization_id,key=key,value=data.value,context=context,)- if removed_count is None:+ if delete_result is None:raise HTTPException(status_code=http_status.HTTP_404_NOT_FOUND,detail=f"Tag value '{key}:{data.value}' not found",)- return TagValueDeleteResponse(key=key, value=data.value, removed_from_workflow_count=removed_count)+ return TagValueDeleteResponse(+ key=key,+ value=data.value,+ removed_from_workflow_count=delete_result.removed_from_workflow_count,+ removed_from_run_count=delete_result.removed_from_run_count,+ removed_count=delete_result.removed_count,+ )# Keep in sync with BATCH_TAGS_MAX_WPIDS in the frontend# useWorkflowTagsBatchQuery hook, which chunks requests to this size._BATCH_TAGS_MAX_WPIDS = 200+_BATCH_TAGS_MAX_RUN_IDS = _BATCH_TAGS_MAX_WPIDSdef _parse_batch_wpids(raw: str | None) -> list[str]:@@ -2139,20 +2390,39 @@ def _parse_batch_wpids(raw: str | None) -> list[str]:return [token.strip() for token in raw.split(",") if token.strip()]+def _parse_batch_run_ids(raw: str | None) -> list[str]:+ """Parse the comma-separated workflow_run_id list from the GET query string."""+ if not raw:+ return []+ return [token.strip() for token in raw.split(",") if token.strip()]+++def _sorted_tag_items(pairs: list[tuple[str | None, str]]) -> list[TagItem]:+ ordered = sorted(pairs, key=lambda kv: (kv[0] is not None, kv[0] or "", kv[1]))+ return [TagItem(key=key, value=value) for key, value in ordered]++def _build_batch_response(requested_wpids: list[str], tag_map: dict[str, list[tuple[str | None, str]]]) -> WorkflowTagsBatchResponse:"""Echo every requested wpid (empty list if no tags). Each list is sortedstandalone-first, then by key, then value — the repo SELECT has no ORDER BY."""- def _sorted(pairs: list[tuple[str | None, str]]) -> list[TagItem]:- ordered = sorted(pairs, key=lambda kv: (kv[0] is not None, kv[0] or "", kv[1]))- return [TagItem(key=key, value=value) for key, value in ordered]-- workflow_tags: dict[str, list[TagItem]] = {wpid: _sorted(tag_map.get(wpid, [])) for wpid in requested_wpids}+ workflow_tags: dict[str, list[TagItem]] = {+ wpid: _sorted_tag_items(tag_map.get(wpid, [])) for wpid in requested_wpids+ }return WorkflowTagsBatchResponse(workflow_tags=workflow_tags)+def _build_run_batch_response(+ requested_run_ids: list[str], tag_map: dict[str, list[tuple[str | None, str]]]+) -> RunTagsBatchResponse:+ run_tags: dict[str, list[TagItem]] = {+ run_id: _sorted_tag_items(tag_map.get(run_id, [])) for run_id in requested_run_ids+ }+ return RunTagsBatchResponse(run_tags=run_tags)++async def _resolve_active_batch_wpids(requested_wpids: list[str], organization_id: str) -> dict[str, list[tuple[str | None, str]]]:@@ -2188,6 +2458,32 @@ async def _resolve_active_batch_wpids(return {wpid: tags for wpid, tags in tag_map.items() if wpid in active_wpids_post}+async def _resolve_active_batch_run_ids(+ requested_run_ids: list[str], organization_id: str+) -> dict[str, list[tuple[str | None, str]]]:+ if not requested_run_ids:+ return {}+ active_runs_pre = await app.DATABASE.workflow_runs.get_workflow_runs_by_ids(+ workflow_run_ids=requested_run_ids,+ organization_id=organization_id,+ )+ active_run_ids_pre = {run.workflow_run_id for run in active_runs_pre}+ if not active_run_ids_pre:+ return {}+ tag_map = await app.DATABASE.tags.get_active_tags_for_runs(+ workflow_run_ids=list(active_run_ids_pre),+ organization_id=organization_id,+ )+ if not tag_map:+ return {}+ active_runs_post = await app.DATABASE.workflow_runs.get_workflow_runs_by_ids(+ workflow_run_ids=list(tag_map.keys()),+ organization_id=organization_id,+ )+ active_run_ids_post = {run.workflow_run_id for run in active_runs_post}+ return {run_id: tags for run_id, tags in tag_map.items() if run_id in active_run_ids_post}++@legacy_base_router.get("/workflow-tags", response_model=WorkflowTagsBatchResponse, tags=["agent"], include_in_schema=False)@@ -2256,6 +2552,70 @@ async def batch_get_workflow_tags_post(return _build_batch_response(wpids, tag_map)+@legacy_base_router.get("/run-tags", response_model=RunTagsBatchResponse, tags=["agent"], include_in_schema=False)+@legacy_base_router.get("/run-tags/", response_model=RunTagsBatchResponse, include_in_schema=False)+@base_router.get(+ "/run-tags",+ response_model=RunTagsBatchResponse,+ tags=["Tags"],+ openapi_extra={"x-hidden": True, "x-fern-sdk-method-name": "batch_get_run_tags"},+ description="Batch fetch current tags for many workflow runs. Avoids N+1 on run-list pages.",+ summary="Batch get run tags",+ responses={+ 200: {"description": "Successfully retrieved tags"},+ 400: {"description": "Too many workflow run IDs requested"},+ },+)+@base_router.get("/run-tags/", response_model=RunTagsBatchResponse, include_in_schema=False)+async def batch_get_run_tags(+ workflow_run_ids: str | None = Query(+ None,+ description="Comma-separated workflow run IDs",+ examples=["wr_123,wr_456"],+ ),+ current_org: Organization = Depends(org_auth_service.get_current_org),+ _tagging_gate: None = Depends(require_workflow_tagging),+) -> RunTagsBatchResponse:+ run_ids = _parse_batch_run_ids(workflow_run_ids)+ if len(run_ids) > _BATCH_TAGS_MAX_RUN_IDS:+ raise HTTPException(+ status_code=http_status.HTTP_400_BAD_REQUEST,+ detail=f"At most {_BATCH_TAGS_MAX_RUN_IDS} workflow run IDs may be requested at once",+ )+ tag_map = await _resolve_active_batch_run_ids(run_ids, current_org.organization_id)+ return _build_run_batch_response(run_ids, tag_map)+++@legacy_base_router.post("/run-tags", response_model=RunTagsBatchResponse, tags=["agent"], include_in_schema=False)+@legacy_base_router.post("/run-tags/", response_model=RunTagsBatchResponse, include_in_schema=False)+@base_router.post(+ "/run-tags",+ response_model=RunTagsBatchResponse,+ tags=["Tags"],+ openapi_extra={"x-hidden": True, "x-fern-sdk-method-name": "batch_get_run_tags_post"},+ description="Batch fetch current tags for many workflow runs (POST variant for id lists exceeding URL length).",+ summary="Batch get run tags (POST)",+ responses={+ 200: {"description": "Successfully retrieved tags"},+ 400: {"description": "Too many workflow run IDs requested"},+ },+)+@base_router.post("/run-tags/", response_model=RunTagsBatchResponse, include_in_schema=False)+async def batch_get_run_tags_post(+ data: RunTagsBatchRequest = Body(...),+ current_org: Organization = Depends(org_auth_service.get_current_org),+ _tagging_gate: None = Depends(require_workflow_tagging),+) -> RunTagsBatchResponse:+ run_ids = [run_id.strip() for run_id in data.workflow_run_ids if run_id and run_id.strip()]+ if len(run_ids) > _BATCH_TAGS_MAX_RUN_IDS:+ raise HTTPException(+ status_code=http_status.HTTP_400_BAD_REQUEST,+ detail=f"At most {_BATCH_TAGS_MAX_RUN_IDS} workflow run IDs may be requested at once",+ )+ tag_map = await _resolve_active_batch_run_ids(run_ids, current_org.organization_id)+ return _build_run_batch_response(run_ids, tag_map)++@legacy_base_router.post("/utilities/curl-to-http",tags=["Utilities"],@@ -3152,6 +3512,14 @@ def _workflow_run_request_from_workflow_request()+def _user_writable_run_metadata(run_metadata: dict[str, str] | None) -> dict[str, str] | None:+ if not run_metadata:+ return None++ filtered = {key: value for key, value in run_metadata.items() if not is_reserved_tag_key(key)}+ return filtered or None++@base_router.post("/workflows/runs/{workflow_run_id}/retry",tags=["Runs"],@@ -3172,12 +3540,13 @@ async def retry_workflow_run(request: Request,background_tasks: BackgroundTasks,workflow_run_id: str = Path(..., description="The id of the workflow run to retry.", examples=["wr_123"]),- current_org: Organization = Depends(org_auth_service.get_current_org),+ caller: org_auth_service.CallerContext = Depends(org_auth_service.get_current_caller_context),x_api_key: Annotated[str | None, Header()] = None,x_max_steps_override: Annotated[int | None, Header()] = None,x_user_agent: Annotated[str | None, Header()] = None,) -> WorkflowRunResponse:analytics.capture("skyvern-oss-agent-workflow-run-retry")+ current_org = caller.organizationoriginal_workflow_run = await app.DATABASE.workflow_runs.get_workflow_run(workflow_run_id=workflow_run_id,organization_id=current_org.organization_id,@@ -3233,13 +3602,15 @@ async def retry_workflow_run(}original_run_metadata = Nonetry:- original_run_metadata = await app.AGENT_FUNCTION.get_workflow_run_metadata(- workflow_run_id=original_workflow_run.workflow_run_id,- organization_id=current_org.organization_id,+ original_run_metadata = _user_writable_run_metadata(+ await app.DATABASE.tags.get_active_grouped_tags_for_run(+ workflow_run_id=original_workflow_run.workflow_run_id,+ organization_id=current_org.organization_id,+ ))except Exception:LOG.warning(- "Failed to fetch workflow run metadata for retry; continuing without metadata",+ "Failed to fetch workflow run tags for retry; continuing without metadata",workflow_run_id=original_workflow_run.workflow_run_id,organization_id=current_org.organization_id,exc_info=True,@@ -3266,6 +3637,7 @@ async def retry_workflow_run(background_tasks=background_tasks,trigger_type=trigger_type,ignore_inherited_workflow_system_prompt=original_workflow_run.ignore_inherited_workflow_system_prompt,+ tag_write_context=_tag_write_context_from_caller(caller),)except MissingBrowserAddressError as e:raise HTTPException(status_code=400, detail=str(e)) from e@@ -3691,13 +4063,14 @@ async def run_workflow_legacy(workflow_id: str, # this is the workflow_permanent_id internallyworkflow_request: WorkflowRequestBody,version: int | None = None,- current_org: Organization = Depends(org_auth_service.get_current_org),+ caller: org_auth_service.CallerContext = Depends(org_auth_service.get_current_caller_context),template: bool = Query(False),x_api_key: Annotated[str | None, Header()] = None,x_max_steps_override: Annotated[int | None, Header()] = None,x_user_agent: Annotated[str | None, Header()] = None,) -> RunWorkflowResponse:analytics.capture("skyvern-oss-agent-workflow-execute")+ current_org = caller.organizationcontext = skyvern_context.ensure_context()request_id = context.request_idawait PermissionCheckerFactory.get_instance().check(@@ -3720,6 +4093,7 @@ async def run_workflow_legacy(request=request,background_tasks=background_tasks,trigger_type=legacy_trigger_type,+ tag_write_context=_tag_write_context_from_caller(caller),)except MissingBrowserAddressError as e:raise HTTPException(status_code=400, detail=str(e)) from ediff --git a/skyvern/forge/sdk/workflow/models/tags.py b/skyvern/forge/sdk/workflow/models/tags.pyindex ca31cf603..1e263196b 100644--- a/skyvern/forge/sdk/workflow/models/tags.py+++ b/skyvern/forge/sdk/workflow/models/tags.py@@ -1,4 +1,5 @@from dataclasses import dataclass+from datetime import datetimefrom enum import StrEnum@@ -10,6 +11,7 @@ class TagSource(StrEnum):BACKFILL = "backfill" # written by a one-off migration/script over existing rowsINHERITED = "inherited" # copied from a parent (e.g. folder) rather than set directlyIMPORT = "import" # ingested from an external system+ SYSTEM = "system" # written by Skyvern-owned automation, not a public callerclass TagEventType(StrEnum):@@ -31,8 +33,12 @@ class CallerType(StrEnum):@dataclass(frozen=True)class TagWriteContext:- """Attribution persisted on each tag event row. caller_type is nullable for backfill scripts."""+ """Attribution persisted on each tag event row.++ ``caller_type`` and ``set_at`` are nullable for backfill scripts.+ """caller_id: strsource: TagSourcecaller_type: CallerType | None = None+ set_at: datetime | None = Nonediff --git a/skyvern/forge/sdk/workflow/models/validators.py b/skyvern/forge/sdk/workflow/models/validators.pyindex c75967d4c..ab0426c0e 100644--- a/skyvern/forge/sdk/workflow/models/validators.py+++ b/skyvern/forge/sdk/workflow/models/validators.py@@ -82,21 +82,26 @@ def _normalize_kv_dict(def normalize_run_metadata(v: dict[str, str] | None) -> dict[str, str] | None:"""Normalize and bound user-supplied workflow run metadata tags."""- return _normalize_kv_dict(+ normalized = _normalize_kv_dict(v,max_keys=RUN_METADATA_MAX_KEYS,max_key_length=RUN_METADATA_MAX_KEY_LENGTH,max_value_length=RUN_METADATA_MAX_VALUE_LENGTH,field_name="run_metadata",)+ if not normalized:+ return None+ return {key: value for key, value in normalized.items() if not is_reserved_tag_key(key)} or None+++def is_reserved_tag_key(key: str) -> bool:+ return key.startswith(SKYVERN_TAG_NAMESPACE)-def _assert_valid_tag_key(key: str) -> None:+def assert_valid_tag_key_shape(key: str) -> None:"""Shape rules for a (trimmed, non-empty) tag key / group. Raises ValueError."""if len(key) > TAG_KEY_MAX_LENGTH:raise ValueError(f"tag keys must be at most {TAG_KEY_MAX_LENGTH} characters")- if key.startswith(SKYVERN_TAG_NAMESPACE):- raise ValueError(f"tag keys must not start with the reserved '{SKYVERN_TAG_NAMESPACE}' prefix")if not TAG_KEY_REGEX.match(key):raise ValueError("tag keys must match '^[A-Za-z0-9][A-Za-z0-9_.-]*$' "@@ -104,9 +109,18 @@ def _assert_valid_tag_key(key: str) -> None:)-def normalize_optional_tag_key(key: object) -> str | None:- """Normalize an optional tag key (group). None or blank -> None (standalone- label); otherwise trim and enforce the key shape rules."""+def assert_user_writable_tag_key(key: str) -> None:+ assert_valid_tag_key_shape(key)+ if is_reserved_tag_key(key):+ raise ValueError(f"tag keys must not start with the reserved '{SKYVERN_TAG_NAMESPACE}' prefix")+++def normalize_optional_tag_key_shape(key: object) -> str | None:+ """Normalize an optional tag key and enforce only shape rules.++ Reserved ``skyvern.*`` keys are valid tag-key shapes; public write surfaces+ layer ``assert_user_writable_tag_key`` on top.+ """if key is None:return Noneif not isinstance(key, str):@@ -114,7 +128,27 @@ def normalize_optional_tag_key(key: object) -> str | None:trimmed = key.strip()if not trimmed:return None- _assert_valid_tag_key(trimmed)+ assert_valid_tag_key_shape(trimmed)+ return trimmed+++def normalize_optional_tag_key(key: object) -> str | None:+ """Normalize an optional tag key (group). None or blank -> None (standalone+ label); otherwise trim and enforce public user-writability."""+ trimmed = normalize_optional_tag_key_shape(key)+ if trimmed is None:+ return None+ assert_user_writable_tag_key(trimmed)+ return trimmed+++def normalize_optional_system_tag_key(key: object) -> str | None:+ """Normalize a system-owned tag key. Only the reserved namespace is writable."""+ trimmed = normalize_optional_tag_key_shape(key)+ if trimmed is None:+ return None+ if not is_reserved_tag_key(trimmed):+ raise ValueError(f"system tag keys must start with the reserved '{SKYVERN_TAG_NAMESPACE}' prefix")return trimmeddiff --git a/skyvern/forge/sdk/workflow/service.py b/skyvern/forge/sdk/workflow/service.pyindex 71b9b026c..5e2512174 100644--- a/skyvern/forge/sdk/workflow/service.py+++ b/skyvern/forge/sdk/workflow/service.py@@ -3,6 +3,7 @@ import copyimport importlib.utilimport jsonimport os+import randomimport textwrapimport timeimport uuid@@ -125,6 +126,7 @@ from skyvern.forge.sdk.workflow.models.parameter import (WorkflowParameterType,)from skyvern.forge.sdk.workflow.models.run_limits import get_effective_workflow_run_max_elapsed_time_minutes+from skyvern.forge.sdk.workflow.models.tags import CallerType, TagSource, TagWriteContextfrom skyvern.forge.sdk.workflow.models.workflow import (Workflow,WorkflowDefinition,@@ -192,6 +194,8 @@ DEFAULT_FIRST_BLOCK_LABEL = "block_1"DEFAULT_WORKFLOW_TITLE = "New Workflow"MANAGED_BROWSER_PROFILE_NAME_MAX_LENGTH = 120MANAGED_BROWSER_PROFILE_KEY_MAX_LENGTH = 40+DETECTED_PLATFORM_RUN_TAG_KEY = "skyvern.platform"+DETECTED_PLATFORM_RUN_TAG_CALLER_ID = "system:platform-detector"# Empirical S3 upload SLA; no start buffer (back-to-back leakage is worse than late uploads to the next run).RECORDING_WINDOW_END_BUFFER = timedelta(minutes=15)@@ -574,6 +578,7 @@ class WorkflowService:run_metadata: dict[str, str] | None,) -> None:"""Persist optional workflow-run metadata while swallowing write failures."""+ # Dormant legacy hook retained until the workflow_run_metadata table drop follow-up.if not run_metadata:return@@ -599,6 +604,7 @@ class WorkflowService:run_metadata: dict[str, str] | None,) -> None:"""Schedule optional workflow-run metadata persistence off the run-creation path."""+ # Dormant legacy hook retained until the workflow_run_metadata table drop follow-up.if not run_metadata:return@@ -612,6 +618,64 @@ class WorkflowService:self._background_tasks.add(task)task.add_done_callback(self._background_tasks.discard)+ @staticmethod+ async def _apply_initial_run_metadata_tags(+ *,+ workflow_run_id: str,+ organization_id: str,+ run_metadata: dict[str, str] | None,+ context: TagWriteContext | None,+ ) -> None:+ if not run_metadata:+ return++ write_context = context or TagWriteContext(+ caller_id=organization_id,+ source=TagSource.SYSTEM,+ caller_type=CallerType.SYSTEM,+ )+ for attempt in range(2):+ try:+ await app.DATABASE.tags.apply_run_tag_changes(+ workflow_run_id=workflow_run_id,+ organization_id=organization_id,+ sets=run_metadata,+ deletes=set(),+ context=write_context,+ )+ return+ except IntegrityError:+ if attempt == 0:+ await asyncio.sleep(random.uniform(0.01, 0.05))+ continue+ raise++ @staticmethod+ async def _apply_detected_platform_run_tag_best_effort(+ *,+ workflow: Workflow,+ workflow_run_id: str,+ organization_id: str,+ parameters: dict[str, Any],+ ) -> None:+ try:+ platform = workflow_script_service.detect_workflow_platform(workflow, parameters)+ if not platform:+ return+ await app.DATABASE.tags.apply_system_run_tag_changes(+ workflow_run_id=workflow_run_id,+ organization_id=organization_id,+ sets={DETECTED_PLATFORM_RUN_TAG_KEY: platform},+ caller_id=DETECTED_PLATFORM_RUN_TAG_CALLER_ID,+ )+ except Exception:+ LOG.warning(+ "Failed to apply detected platform workflow run tag",+ workflow_run_id=workflow_run_id,+ organization_id=organization_id,+ exc_info=True,+ )+@staticmethoddef _determine_cache_invalidation(previous_blocks: list[dict[str, Any]],@@ -1253,6 +1317,7 @@ class WorkflowService:ignore_inherited_workflow_system_prompt: bool = False,copilot_session_id: str | None = None,resolved_workflow_id: str | None = None,+ tag_write_context: TagWriteContext | None = None,) -> WorkflowRun:"""Create a workflow run and its parameters. Validate the workflow and the organization. If there are missing@@ -1360,11 +1425,20 @@ class WorkflowService:ignore_inherited_workflow_system_prompt=ignore_inherited_workflow_system_prompt,copilot_session_id=resolved_copilot_session_id,)- self._record_workflow_run_metadata_in_background(- workflow_run_id=workflow_run.workflow_run_id,- organization_id=organization.organization_id,- run_metadata=workflow_request.run_metadata,- )+ try:+ await self._apply_initial_run_metadata_tags(+ workflow_run_id=workflow_run.workflow_run_id,+ organization_id=organization.organization_id,+ run_metadata=workflow_request.run_metadata,+ context=tag_write_context,+ )+ except Exception:+ LOG.warning(+ "Failed to apply initial workflow run metadata tags",+ workflow_run_id=workflow_run.workflow_run_id,+ organization_id=organization.organization_id,+ exc_info=True,+ )LOG.info(f"Created workflow run {workflow_run.workflow_run_id} for workflow {workflow.workflow_id}",@@ -1546,6 +1620,12 @@ class WorkflowService:workflow_run_id=workflow_run.workflow_run_id,batch_error=str(batch_error),)+ await self._apply_detected_platform_run_tag_best_effort(+ workflow=workflow,+ workflow_run_id=workflow_run.workflow_run_id,+ organization_id=organization.organization_id,+ parameters=parameter_values,+ )except Exception as e:LOG.exception(f"Error while setting up workflow run {workflow_run.workflow_run_id}",diff --git a/skyvern/forge/sdk/workflow/workflow_definition_converter.py b/skyvern/forge/sdk/workflow/workflow_definition_converter.pyindex 05b860126..99165cecf 100644--- a/skyvern/forge/sdk/workflow/workflow_definition_converter.py+++ b/skyvern/forge/sdk/workflow/workflow_definition_converter.py@@ -639,6 +639,22 @@ def block_yaml_to_block(path=block_yaml.path,)elif block_yaml.block_type == BlockType.SEND_EMAIL:+ missing_smtp_keys = [+ key+ for key in (+ block_yaml.smtp_host_secret_parameter_key,+ block_yaml.smtp_port_secret_parameter_key,+ block_yaml.smtp_username_secret_parameter_key,+ block_yaml.smtp_password_secret_parameter_key,+ )+ if key not in parameters+ ]+ if missing_smtp_keys:+ raise InvalidWorkflowDefinition(+ f"Send email block '{block_yaml.label}' references undefined parameter(s): "+ f"{', '.join(sorted(set(missing_smtp_keys)))}. "+ "Declare these parameters in the workflow before using them."+ )return SendEmailBlock(**base_kwargs,smtp_host=parameters[block_yaml.smtp_host_secret_parameter_key],diff --git a/skyvern/schemas/tags.py b/skyvern/schemas/tags.pyindex bf5e31a82..5a6ec1879 100644--- a/skyvern/schemas/tags.py+++ b/skyvern/schemas/tags.py@@ -8,9 +8,8 @@ from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validafrom skyvern.forge.sdk.workflow.models.validators import (RUN_METADATA_MAX_KEYS,- SKYVERN_TAG_NAMESPACE,TAG_DESCRIPTION_MAX_LENGTH,- TAG_KEY_REGEX,+ assert_user_writable_tag_key,normalize_optional_tag_key,normalize_optional_tag_value,normalize_tag_color,@@ -27,13 +26,7 @@ def _assert_user_key_writable(key: str) -> None:write paths."""if not isinstance(key, str):raise ValueError("tag key must be a string")- if key.startswith(SKYVERN_TAG_NAMESPACE):- raise ValueError(f"tag keys must not start with the reserved '{SKYVERN_TAG_NAMESPACE}' prefix")- if not TAG_KEY_REGEX.match(key):- raise ValueError(- "tag keys must match '^[A-Za-z0-9][A-Za-z0-9_.-]*$' "- "(alphanumeric, underscore, dot, hyphen; must start with alphanumeric)"- )+ assert_user_writable_tag_key(key)class TagInput(BaseModel):@@ -171,6 +164,13 @@ class TagsResponse(BaseModel):tags: list[TagResponse]+class RunTagsResponse(BaseModel):+ """Current tags for a workflow run."""++ workflow_run_id: str+ tags: list[TagResponse]++class TagHistoryItem(BaseModel):"""One row from ``GET /v1/workflows/{wpid}/tags/history``."""@@ -191,6 +191,11 @@ class TagHistoryResponse(BaseModel):events: list[TagHistoryItem]+class RunTagHistoryResponse(BaseModel):+ workflow_run_id: str+ events: list[TagHistoryItem]++class TagKey(BaseModel):"""Tag-key registry entry."""@@ -208,6 +213,8 @@ class TagKeyDeleteResponse(BaseModel):key: strremoved_from_workflow_count: int+ removed_from_run_count: int = 0+ removed_count: int = 0class TagKeyUpdate(BaseModel):@@ -311,6 +318,8 @@ class TagValueDeleteResponse(BaseModel):key: strvalue: strremoved_from_workflow_count: int+ removed_from_run_count: int = 0+ removed_count: int = 0class WorkflowTagsBatchRequest(BaseModel):@@ -323,6 +332,16 @@ class WorkflowTagsBatchRequest(BaseModel):)+class RunTagsBatchRequest(BaseModel):+ """Body for ``POST /v1/run-tags`` (used when the run-id list would exceed+ the URL length cap)."""++ workflow_run_ids: list[str] = Field(+ default_factory=list,+ description="Workflow run IDs to fetch tags for.",+ )++class TagItem(BaseModel):"""A single tag (key + label) without per-tag attribution. ``key`` is nullfor a standalone label."""@@ -339,3 +358,13 @@ class WorkflowTagsBatchResponse(BaseModel):Workflows outside the caller's org are silently absent (no leakage)."""workflow_tags: dict[str, list[TagItem]]+++class RunTagsBatchResponse(BaseModel):+ """Response for the run-tags batch endpoint.++ Runs with no tags are present with an empty list so the frontend can+ distinguish "fetched, none set" from "not fetched" without a second call.+ Runs outside the caller's org are silently absent (no leakage)."""++ run_tags: dict[str, list[TagItem]]diff --git a/skyvern/services/workflow_script_service.py b/skyvern/services/workflow_script_service.pyindex c8c7afc89..19f4ad217 100644--- a/skyvern/services/workflow_script_service.py+++ b/skyvern/services/workflow_script_service.py@@ -284,6 +284,20 @@ def _extract_first_block_domain(workflow: Workflow, parameters: dict[str, Any],return ""+def detect_workflow_platform(+ workflow: Workflow,+ parameters: dict[str, Any],+ *,+ strict: bool = False,+ domain_override: str | None = None,+) -> str | None:+ """Detect the Skyvern-supported platform for a workflow's first resolvable block URL."""+ domain = domain_override or _extract_first_block_domain(workflow, parameters, strict=strict)+ if not domain:+ return None+ return app.AGENT_FUNCTION.detect_ats_platform(domain)++def resolve_cache_key_value(workflow: Workflow,parameters: dict[str, Any],@@ -310,7 +324,12 @@ def resolve_cache_key_value("Unable to resolve default cache key: provide cache_context.parameters or domain_override")if domain:- ats_platform = app.AGENT_FUNCTION.detect_ats_platform(domain)+ ats_platform = detect_workflow_platform(+ workflow,+ parameters,+ strict=strict,+ domain_override=domain,+ )if ats_platform:LOG.info("Code 2.0: platform detected, using platform-level cache key",diff --git a/skyvern/services/workflow_service.py b/skyvern/services/workflow_service.pyindex dbce71494..551cc1f73 100644--- a/skyvern/services/workflow_service.py+++ b/skyvern/services/workflow_service.py@@ -9,6 +9,7 @@ from skyvern.forge.sdk.db.enums import WorkflowRunTriggerTypefrom skyvern.forge.sdk.executor.factory import AsyncExecutorFactoryfrom skyvern.forge.sdk.schemas.organizations import Organizationfrom skyvern.forge.sdk.workflow.exceptions import InvalidTemplateWorkflowPermanentId+from skyvern.forge.sdk.workflow.models.tags import TagWriteContextfrom skyvern.forge.sdk.workflow.models.workflow import WorkflowRequestBody, WorkflowRunfrom skyvern.schemas.runs import RunStatus, RunType, WorkflowRunRequest, WorkflowRunResponse@@ -32,6 +33,7 @@ async def prepare_workflow(ignore_inherited_workflow_system_prompt: bool = False,copilot_session_id: str | None = None,resolved_workflow_id: str | None = None,+ tag_write_context: TagWriteContext | None = None,) -> WorkflowRun:"""Prepare a workflow to be run.@@ -60,6 +62,7 @@ async def prepare_workflow(ignore_inherited_workflow_system_prompt=ignore_inherited_workflow_system_prompt,copilot_session_id=copilot_session_id,resolved_workflow_id=resolved_workflow_id,+ tag_write_context=tag_write_context,)if resolved_workflow_id is not None:@@ -108,6 +111,7 @@ async def run_workflow(trigger_type: WorkflowRunTriggerType | None = None,workflow_schedule_id: str | None = None,ignore_inherited_workflow_system_prompt: bool = False,+ tag_write_context: TagWriteContext | None = None,) -> WorkflowRun:workflow_run = await prepare_workflow(workflow_id=workflow_id,@@ -121,6 +125,7 @@ async def run_workflow(trigger_type=trigger_type,workflow_schedule_id=workflow_schedule_id,ignore_inherited_workflow_system_prompt=ignore_inherited_workflow_system_prompt,+ tag_write_context=tag_write_context,)await AsyncExecutorFactory.get_executor().execute_workflow(diff --git a/tests/unit/test_runs_v2_route.py b/tests/unit/test_runs_v2_route.pyindex 488dcde4a..0627c948f 100644--- a/tests/unit/test_runs_v2_route.py+++ b/tests/unit/test_runs_v2_route.py@@ -10,10 +10,19 @@ from fastapi import BackgroundTasks, HTTPExceptionfrom skyvern.exceptions import WorkflowNotFoundfrom skyvern.forge.sdk.db.enums import WorkflowRunTriggerTypefrom skyvern.forge.sdk.routes import agent_protocol+from skyvern.forge.sdk.workflow.models.tags import CallerType, TagSourcefrom skyvern.forge.sdk.workflow.models.workflow import WorkflowRequestBody, WorkflowRunStatusfrom skyvern.schemas.runs import MAX_SEARCH_FETCH_LIMIT+def _caller(org_id: str = "org_123") -> SimpleNamespace:+ return SimpleNamespace(+ organization=SimpleNamespace(organization_id=org_id),+ caller_id="user_123",+ caller_type=CallerType.USER,+ )++@pytest.mark.asyncioasync def test_get_runs_v2_serializes_mapping_rows_from_database(monkeypatch: pytest.MonkeyPatch) -> None:mock_workflow_runs = SimpleNamespace(@@ -181,8 +190,11 @@ async def test_retry_workflow_run_replays_original_run_parameters(monkeypatch: preturn_value=[(SimpleNamespace(key="customer"), SimpleNamespace(value="acme"))]),)+ mock_tags = SimpleNamespace(+ get_active_grouped_tags_for_run=AsyncMock(return_value={"env": "prod", "skyvern.platform": "example-platform"})+ )mock_debug = SimpleNamespace(has_block_run_for_workflow_run=AsyncMock(return_value=False))- mock_database = SimpleNamespace(workflow_runs=mock_workflow_runs, debug=mock_debug)+ mock_database = SimpleNamespace(workflow_runs=mock_workflow_runs, debug=mock_debug, tags=mock_tags)mock_workflow_service = SimpleNamespace(get_workflow=AsyncMock(return_value=SimpleNamespace(version=7, title="Original workflow title", organization_id="org_123")@@ -197,7 +209,6 @@ async def test_retry_workflow_run_replays_original_run_parameters(monkeypatch: pmonkeypatch.setattr(agent_protocol.skyvern_context, "ensure_context", lambda: SimpleNamespace(request_id="req_123"))mock_agent_function = SimpleNamespace(is_block_scoped_workflow_run=AsyncMock(return_value=False),- get_workflow_run_metadata=AsyncMock(return_value={"env": "prod"}),)monkeypatch.setattr(app_instance, "AGENT_FUNCTION", mock_agent_function, raising=False)@@ -211,11 +222,12 @@ async def test_retry_workflow_run_replays_original_run_parameters(monkeypatch: prun_workflow_mock = AsyncMock(return_value=retried_run)monkeypatch.setattr(agent_protocol.workflow_service, "run_workflow", run_workflow_mock)+ caller = _caller()response = await agent_protocol.retry_workflow_run(request=SimpleNamespace(),background_tasks=BackgroundTasks(),workflow_run_id="wr_original",- current_org=SimpleNamespace(organization_id="org_123"),+ caller=caller,x_api_key="api-key",x_max_steps_override=10,x_user_agent="skyvern-ui",@@ -230,9 +242,7 @@ async def test_retry_workflow_run_replays_original_run_parameters(monkeypatch: pworkflow_run_id="wr_original",)mock_agent_function.is_block_scoped_workflow_run.assert_awaited_once_with(original_run)- mock_permission_checker.check.assert_awaited_once_with(- SimpleNamespace(organization_id="org_123"), browser_session_id="pbs_123"- )+ mock_permission_checker.check.assert_awaited_once_with(caller.organization, browser_session_id="pbs_123")mock_rate_limiter.rate_limit_submit_run.assert_awaited_once_with("org_123")mock_workflow_service.get_workflow.assert_awaited_once_with(workflow_id="wf_original",@@ -241,7 +251,7 @@ async def test_retry_workflow_run_replays_original_run_parameters(monkeypatch: pmock_workflow_runs.get_workflow_run_parameters.assert_awaited_once_with(workflow_run_id="wr_original",)- mock_agent_function.get_workflow_run_metadata.assert_awaited_once_with(+ mock_tags.get_active_grouped_tags_for_run.assert_awaited_once_with(workflow_run_id="wr_original",organization_id="org_123",)@@ -256,6 +266,9 @@ async def test_retry_workflow_run_replays_original_run_parameters(monkeypatch: passert call_kwargs["request_id"] == "req_123"assert call_kwargs["trigger_type"] == WorkflowRunTriggerType.manualassert call_kwargs["ignore_inherited_workflow_system_prompt"] is True+ assert call_kwargs["tag_write_context"].caller_id == "user_123"+ assert call_kwargs["tag_write_context"].source == TagSource.MANUAL+ assert call_kwargs["tag_write_context"].caller_type == CallerType.USERassert isinstance(call_kwargs["workflow_request"], WorkflowRequestBody)assert call_kwargs["workflow_request"].data == {"customer": "acme"}assert call_kwargs["workflow_request"].webhook_callback_url == "https://example.com/webhook"@@ -310,7 +323,7 @@ async def test_retry_workflow_run_rejects_block_scoped_run(monkeypatch: pytest.Mrequest=SimpleNamespace(),background_tasks=BackgroundTasks(),workflow_run_id="wr_block",- current_org=SimpleNamespace(organization_id="org_123"),+ caller=_caller(),x_api_key=None,x_max_steps_override=None,x_user_agent=None,@@ -365,7 +378,8 @@ async def test_retry_workflow_run_replays_template_runs_as_templates(monkeypatchget_workflow_run_parameters=AsyncMock(return_value=[]),)mock_debug = SimpleNamespace(has_block_run_for_workflow_run=AsyncMock(return_value=False))- mock_database = SimpleNamespace(workflow_runs=mock_workflow_runs, debug=mock_debug)+ mock_tags = SimpleNamespace(get_active_grouped_tags_for_run=AsyncMock(side_effect=RuntimeError("tags unavailable")))+ mock_database = SimpleNamespace(workflow_runs=mock_workflow_runs, debug=mock_debug, tags=mock_tags)mock_workflow_service = SimpleNamespace(get_workflow=AsyncMock(return_value=SimpleNamespace(version=3, title="Template title", organization_id="template_org")@@ -381,7 +395,6 @@ async def test_retry_workflow_run_replays_template_runs_as_templates(monkeypatch"AGENT_FUNCTION",SimpleNamespace(is_block_scoped_workflow_run=AsyncMock(return_value=False),- get_workflow_run_metadata=AsyncMock(side_effect=RuntimeError("metadata unavailable")),),raising=False,)@@ -400,7 +413,7 @@ async def test_retry_workflow_run_replays_template_runs_as_templates(monkeypatchrequest=SimpleNamespace(),background_tasks=BackgroundTasks(),workflow_run_id="wr_template",- current_org=SimpleNamespace(organization_id="org_123"),+ caller=_caller(),x_api_key=None,x_max_steps_override=None,x_user_agent=None,@@ -411,6 +424,7 @@ async def test_retry_workflow_run_replays_template_runs_as_templates(monkeypatchassert run_workflow_mock.call_args.kwargs["version"] == 3assert run_workflow_mock.call_args.kwargs["ignore_inherited_workflow_system_prompt"] is Falseassert run_workflow_mock.call_args.kwargs["workflow_request"].run_metadata is None+ assert run_workflow_mock.call_args.kwargs["tag_write_context"].caller_id == "user_123"mock_workflow_service.get_workflow.assert_awaited_once_with(workflow_id="wf_template",organization_id=None,@@ -464,7 +478,7 @@ async def test_retry_workflow_run_rejects_missing_workflow(monkeypatch: pytest.Mrequest=SimpleNamespace(),background_tasks=BackgroundTasks(),workflow_run_id="wr_missing_workflow",- current_org=SimpleNamespace(organization_id="org_123"),+ caller=_caller(),x_api_key=None,x_max_steps_override=None,x_user_agent=None,@@ -490,7 +504,7 @@ async def test_retry_workflow_run_rejects_active_run(monkeypatch: pytest.MonkeyPrequest=SimpleNamespace(),background_tasks=BackgroundTasks(),workflow_run_id="wr_running",- current_org=SimpleNamespace(organization_id="org_123"),+ caller=_caller(),x_api_key=None,x_max_steps_override=None,x_user_agent=None,diff --git a/tests/unit/test_send_email_block.py b/tests/unit/test_send_email_block.pynew file mode 100644index 000000000..dc734e9da--- /dev/null+++ b/tests/unit/test_send_email_block.py@@ -0,0 +1,74 @@+"""SEND_EMAIL block conversion (SKY-12062): a send_email block that references+an smtp_* secret parameter which was never declared in the workflow's parameters+must surface as a handled validation error (422), not a bare KeyError (500)."""++from __future__ import annotations++from datetime import UTC, datetime++import pytest++from skyvern.forge.sdk.workflow.exceptions import InvalidWorkflowDefinition+from skyvern.forge.sdk.workflow.models.block import SendEmailBlock+from skyvern.forge.sdk.workflow.models.parameter import AWSSecretParameter, OutputParameter, ParameterType+from skyvern.forge.sdk.workflow.workflow_definition_converter import block_yaml_to_block+from skyvern.schemas.workflows import SendEmailBlockYAML+++def _output_parameter(label: str) -> OutputParameter:+ now = datetime.now(UTC)+ return OutputParameter(+ parameter_type=ParameterType.OUTPUT,+ key=f"{label}_output",+ output_parameter_id="op_1",+ workflow_id="w_1",+ created_at=now,+ modified_at=now,+ )+++def _aws_secret_parameter(key: str) -> AWSSecretParameter:+ now = datetime.now(UTC)+ return AWSSecretParameter(+ key=key,+ aws_secret_parameter_id=f"asp_{key}",+ workflow_id="w_1",+ aws_key=key,+ created_at=now,+ modified_at=now,+ )+++def _send_email_block_yaml() -> SendEmailBlockYAML:+ return SendEmailBlockYAML(+ label="send_email",+ smtp_host_secret_parameter_key="smtp_host",+ smtp_port_secret_parameter_key="smtp_port",+ smtp_username_secret_parameter_key="smtp_username",+ smtp_password_secret_parameter_key="smtp_password",+ sender="[email protected]",+ recipients=["[email protected]"],+ subject="subject",+ body="body",+ )+++def test_undeclared_smtp_parameter_raises_invalid_workflow_definition() -> None:+ parameters = {"send_email_output": _output_parameter("send_email")}+ with pytest.raises(InvalidWorkflowDefinition) as exc_info:+ block_yaml_to_block(_send_email_block_yaml(), parameters)+ assert "smtp_host" in str(exc_info.value)+++def test_declared_smtp_parameters_convert_successfully() -> None:+ parameters = {+ "send_email_output": _output_parameter("send_email"),+ "smtp_host": _aws_secret_parameter("smtp_host"),+ "smtp_port": _aws_secret_parameter("smtp_port"),+ "smtp_username": _aws_secret_parameter("smtp_username"),+ "smtp_password": _aws_secret_parameter("smtp_password"),+ }+ block = block_yaml_to_block(_send_email_block_yaml(), parameters)+ assert isinstance(block, SendEmailBlock)+ assert block.smtp_host.key == "smtp_host"+ assert block.smtp_password.key == "smtp_password"diff --git a/tests/unit/test_tag_endpoints.py b/tests/unit/test_tag_endpoints.pyindex b950d63bd..ac90581d6 100644--- a/tests/unit/test_tag_endpoints.py+++ b/tests/unit/test_tag_endpoints.py@@ -24,7 +24,7 @@ from sqlalchemy.exc import IntegrityErrorfrom sqlalchemy.ext.asyncio import AsyncEngine, async_sessionmaker, create_async_enginefrom skyvern.forge.sdk.db.base_alchemy_db import BaseAlchemyDB-from skyvern.forge.sdk.db.models import Base, WorkflowModel+from skyvern.forge.sdk.db.models import Base, WorkflowModel, WorkflowRunModelfrom skyvern.forge.sdk.db.repositories.tags import TagsRepositoryfrom skyvern.forge.sdk.schemas.organizations import Organizationfrom skyvern.forge.sdk.services import org_auth_service@@ -34,6 +34,8 @@ ORG_ID = "o_test"OTHER_ORG_ID = "o_other"WPID = "wpid_alpha"OTHER_WPID = "wpid_beta"+WRID = "wr_alpha"+OTHER_WRID = "wr_beta"CALLER_ID = "user_test"@@ -59,6 +61,24 @@ async def engine() -> AsyncGenerator[AsyncEngine]:session.add(WorkflowModel(organization_id=ORG_ID, workflow_permanent_id=WPID, title="t", workflow_definition={}))+ session.add(+ WorkflowRunModel(+ workflow_run_id=WRID,+ workflow_id="wf_alpha",+ workflow_permanent_id=WPID,+ organization_id=ORG_ID,+ status="completed",+ )+ )+ session.add(+ WorkflowRunModel(+ workflow_run_id=OTHER_WRID,+ workflow_id="wf_beta",+ workflow_permanent_id=OTHER_WPID,+ organization_id=OTHER_ORG_ID,+ status="completed",+ )+ )await session.commit()yield engawait eng.dispose()@@ -117,9 +137,38 @@ def app_with_routes(repo: TagsRepository, monkeypatch: pytest.MonkeyPatch) -> Faworkflows_mock.get_existing_permanent_ids = AsyncMock(side_effect=_get_existing_permanent_ids)+ workflow_runs_mock = MagicMock()++ async def _get_workflow_run(+ workflow_run_id: str,+ organization_id: str | None = None,+ **kwargs: object,+ ) -> object | None:+ if workflow_run_id == WRID and organization_id == ORG_ID:+ return MagicMock(workflow_run_id=WRID, organization_id=ORG_ID)+ if workflow_run_id == OTHER_WRID and organization_id == OTHER_ORG_ID:+ return MagicMock(workflow_run_id=OTHER_WRID, organization_id=OTHER_ORG_ID)+ return None++ workflow_runs_mock.get_workflow_run = AsyncMock(side_effect=_get_workflow_run)++ async def _get_workflow_runs_by_ids(+ workflow_run_ids: list[str],+ workflow_permanent_id: str | None = None,+ organization_id: str | None = None,+ ) -> list[object]:+ if organization_id == ORG_ID:+ return [MagicMock(workflow_run_id=run_id) for run_id in workflow_run_ids if run_id == WRID]+ if organization_id == OTHER_ORG_ID:+ return [MagicMock(workflow_run_id=run_id) for run_id in workflow_run_ids if run_id == OTHER_WRID]+ return []++ workflow_runs_mock.get_workflow_runs_by_ids = AsyncMock(side_effect=_get_workflow_runs_by_ids)+database_mock = MagicMock()database_mock.tags = repodatabase_mock.workflows = workflows_mock+ database_mock.workflow_runs = workflow_runs_mockapp_mock = MagicMock()app_mock.DATABASE = database_mock@@ -213,6 +262,11 @@ def test_post_tags_invalid_key_returns_422(client: TestClient) -> None:assert resp.status_code == 422+def test_post_run_tags_reserved_namespace_returns_422(client: TestClient) -> None:+ resp = client.post(f"/v1/runs/{WRID}/tags", json={"tags": [{"key": "skyvern.foo", "value": "bar"}]})+ assert resp.status_code == 422++def test_post_tags_bad_value_char_returns_422(client: TestClient) -> None:"""Comma in value would break the ``?tags=`` filter encoding."""resp = client.post(f"/v1/workflows/{WPID}/tags", json={"tags": [{"key": "team", "value": "a,b"}]})@@ -379,6 +433,121 @@ def test_get_history_filter_by_key(client: TestClient) -> None:assert len(events) == 1+# ----------------------------- Run tag endpoints ------------------------------------+++def test_post_run_tags_sets_grouped_and_standalone_tags(client: TestClient) -> None:+ resp = client.post(+ f"/v1/runs/{WRID}/tags",+ json={"tags": [{"key": "env", "value": "prod"}, {"value": "urgent"}]},+ )++ assert resp.status_code == 200, resp.text+ body = resp.json()+ assert body["workflow_run_id"] == WRID+ assert body["tags"] == [+ {+ "key": None,+ "value": "urgent",+ "source": "manual",+ "set_at": body["tags"][0]["set_at"],+ "set_by": CALLER_ID,+ },+ {+ "key": "env",+ "value": "prod",+ "source": "manual",+ "set_at": body["tags"][1]["set_at"],+ "set_by": CALLER_ID,+ },+ ]+++def test_get_run_tags_returns_current_state(client: TestClient) -> None:+ client.post(f"/v1/runs/{WRID}/tags", json={"tags": [{"key": "env", "value": "prod"}]})++ resp = client.get(f"/v1/runs/{WRID}/tags")++ assert resp.status_code == 200+ assert resp.json()["workflow_run_id"] == WRID+ assert resp.json()["tags"][0]["key"] == "env"+++def test_delete_run_tag_supersedes_prior_set(client: TestClient) -> None:+ client.post(+ f"/v1/runs/{WRID}/tags",+ json={"tags": [{"key": "env", "value": "prod"}, {"key": "team", "value": "growth"}]},+ )++ resp = client.delete(f"/v1/runs/{WRID}/tags/env")++ assert resp.status_code == 200, resp.text+ tags = resp.json()["tags"]+ assert _keys(tags) == {"team"}+++def test_get_run_tag_history_filters_by_key(client: TestClient) -> None:+ client.post(+ f"/v1/runs/{WRID}/tags",+ json={"tags": [{"key": "env", "value": "prod"}, {"key": "team", "value": "growth"}]},+ )++ resp = client.get(f"/v1/runs/{WRID}/tags/history?key=team")++ assert resp.status_code == 200+ body = resp.json()+ assert body["workflow_run_id"] == WRID+ assert [event["key"] for event in body["events"]] == ["team"]+++def test_run_tag_routes_404_when_run_not_in_org(client: TestClient) -> None:+ resp = client.post(+ f"/v1/runs/{OTHER_WRID}/tags",+ json={"tags": [{"key": "env", "value": "prod"}]},+ )++ assert resp.status_code == 404+++def test_run_tag_noop_404_when_run_not_in_org(client: TestClient) -> None:+ resp = client.post(f"/v1/runs/{OTHER_WRID}/tags", json={"tags": [], "tags_to_delete": []})++ assert resp.status_code == 404+++def test_batch_get_run_tags_echoes_requested_ids(client: TestClient) -> None:+ client.post(+ f"/v1/runs/{WRID}/tags",+ json={"tags": [{"key": "team", "value": "growth"}, {"key": "env", "value": "prod"}]},+ )++ resp = client.get(f"/v1/run-tags?workflow_run_ids={WRID},wr_missing")++ assert resp.status_code == 200, resp.text+ assert resp.json()["run_tags"] == {+ WRID: [{"key": "env", "value": "prod"}, {"key": "team", "value": "growth"}],+ "wr_missing": [],+ }+++def test_batch_post_run_tags_accepts_body(client: TestClient) -> None:+ client.post(f"/v1/runs/{WRID}/tags", json={"tags": [{"key": "env", "value": "prod"}]})++ resp = client.post("/v1/run-tags", json={"workflow_run_ids": [WRID]})++ assert resp.status_code == 200, resp.text+ assert resp.json()["run_tags"] == {WRID: [{"key": "env", "value": "prod"}]}+++def test_run_tags_legacy_routes_work(client: TestClient) -> None:+ resp = client.post("/api/v1/runs/wr_alpha/tags", json={"tags": [{"key": "env", "value": "prod"}]})++ assert resp.status_code == 200, resp.text+ assert client.get("/api/v1/run-tags?workflow_run_ids=wr_alpha").json()["run_tags"] == {+ WRID: [{"key": "env", "value": "prod"}]+ }++# ----------------------------- GET/PATCH /tag-keys -----------------------------------@@ -445,7 +614,12 @@ def test_delete_tag_key_removes_from_registry_and_workflow(client: TestClient) -resp = client.delete("/v1/tag-keys/env")assert resp.status_code == 200- assert resp.json() == {"key": "env", "removed_from_workflow_count": 1}+ assert resp.json() == {+ "key": "env",+ "removed_from_workflow_count": 1,+ "removed_from_run_count": 0,+ "removed_count": 1,+ }assert [row["key"] for row in client.get("/v1/tag-keys").json()] == ["team"]assert _keys(client.get(f"/v1/workflows/{WPID}/tags").json()["tags"]) == {"team"}@@ -465,6 +639,22 @@ def test_delete_tag_key_legacy_route_works(client: TestClient) -> None:resp = client.delete("/api/v1/tag-keys/env")assert resp.status_code == 200assert resp.json()["removed_from_workflow_count"] == 1+ assert resp.json()["removed_count"] == 1+++def test_delete_tag_key_response_includes_run_count(client: TestClient) -> None:+ client.post(f"/v1/workflows/{WPID}/tags", json={"tags": [{"key": "env", "value": "prod"}]})+ client.post(f"/v1/runs/{WRID}/tags", json={"tags": [{"key": "env", "value": "prod"}]})++ resp = client.delete("/v1/tag-keys/env")++ assert resp.status_code == 200, resp.text+ assert resp.json() == {+ "key": "env",+ "removed_from_workflow_count": 1,+ "removed_from_run_count": 1,+ "removed_count": 2,+ }# ----------------------------- Batch endpoints ---------------------------------------@@ -597,6 +787,11 @@ def test_delete_path_reserved_namespace_returns_400(client: TestClient) -> None:assert resp.status_code == 400+def test_run_delete_path_reserved_namespace_returns_400(client: TestClient) -> None:+ resp = client.delete(f"/v1/runs/{WRID}/tags/skyvern.managed")+ assert resp.status_code == 400++def test_delete_path_bad_shape_returns_400(client: TestClient) -> None:"""CORR-3: same path-level rule for shape (regex) violations."""resp = client.delete(f"/v1/workflows/{WPID}/tags/.leading-dot")@@ -746,6 +941,36 @@ def test_get_tag_values_legacy_route_works(client: TestClient) -> None:assert resp.json()[0]["color"] == "green"+def test_get_tag_values_filters_by_key(client: TestClient) -> None:+ client.post(+ f"/v1/workflows/{WPID}/tags",+ json={+ "tags": [{"key": "env", "value": "prod"}, {"key": "team", "value": "growth"}],+ "colors": {"env": "green", "team": "purple"},+ },+ )++ resp = client.get("/v1/tag-values?key=team")++ assert resp.status_code == 200+ assert [(row["key"], row["value"], row["color"]) for row in resp.json()] == [("team", "growth", "purple")]+++def test_get_tag_values_legacy_route_filters_by_key(client: TestClient) -> None:+ client.post(+ f"/v1/workflows/{WPID}/tags",+ json={+ "tags": [{"key": "env", "value": "prod"}, {"key": "region", "value": "us-west"}],+ "colors": {"env": "green", "region": "red"},+ },+ )++ resp = client.get("/api/v1/tag-values?key=region")++ assert resp.status_code == 200+ assert [(row["key"], row["value"], row["color"]) for row in resp.json()] == [("region", "us-west", "red")]++def test_post_tags_invalid_color_returns_422(client: TestClient) -> None:resp = client.post(f"/v1/workflows/{WPID}/tags",@@ -929,7 +1154,13 @@ def test_delete_tag_value_cascades_and_returns_count(client: TestClient) -> None)resp = client.request("DELETE", "/v1/tag-values/env", json={"value": "prod"})assert resp.status_code == 200, resp.text- assert resp.json() == {"key": "env", "value": "prod", "removed_from_workflow_count": 1}+ assert resp.json() == {+ "key": "env",+ "value": "prod",+ "removed_from_workflow_count": 1,+ "removed_from_run_count": 0,+ "removed_count": 1,+ }# The label is gone from the workflow and from the value registry.assert client.get(f"/v1/workflows/{WPID}/tags").json()["tags"] == []assert client.get("/v1/tag-values").json() == []@@ -957,3 +1188,20 @@ def test_delete_tag_value_legacy_route_works(client: TestClient) -> None:resp = client.request("DELETE", "/api/v1/tag-values/env", json={"value": "prod"})assert resp.status_code == 200, resp.textassert resp.json()["removed_from_workflow_count"] == 1+ assert resp.json()["removed_count"] == 1+++def test_delete_tag_value_response_includes_run_count(client: TestClient) -> None:+ client.post(f"/v1/workflows/{WPID}/tags", json={"tags": [{"key": "env", "value": "prod"}]})+ client.post(f"/v1/runs/{WRID}/tags", json={"tags": [{"key": "env", "value": "prod"}]})++ resp = client.request("DELETE", "/v1/tag-values/env", json={"value": "prod"})++ assert resp.status_code == 200, resp.text+ assert resp.json() == {+ "key": "env",+ "value": "prod",+ "removed_from_workflow_count": 1,+ "removed_from_run_count": 1,+ "removed_count": 2,+ }diff --git a/tests/unit/test_tag_validators.py b/tests/unit/test_tag_validators.pyindex aa62d45b7..dfbce7c12 100644--- a/tests/unit/test_tag_validators.py+++ b/tests/unit/test_tag_validators.py@@ -7,6 +7,7 @@ from skyvern.forge.sdk.workflow.models.validators import (TAG_DESCRIPTION_MAX_LENGTH,TAG_KEY_MAX_LENGTH,TAG_VALUE_MAX_LENGTH,+ normalize_optional_system_tag_key,normalize_optional_tag_key,normalize_optional_tag_value,normalize_run_metadata,@@ -30,6 +31,12 @@ class TestNormalizeRunMetadataUnchanged:def test_all_empty_returns_none(self) -> None:assert normalize_run_metadata({"": "", " ": " "}) is None+ def test_reserved_namespace_keys_are_filtered(self) -> None:+ assert normalize_run_metadata({"env": "prod", " skyvern.platform ": "shop"}) == {"env": "prod"}++ def test_all_reserved_namespace_keys_return_none(self) -> None:+ assert normalize_run_metadata({"skyvern.platform": "shop"}) is None+def test_over_max_keys_raises(self) -> None:too_many = {f"k{i}": "v" for i in range(RUN_METADATA_MAX_KEYS + 1)}with pytest.raises(ValueError, match="at most"):@@ -104,6 +111,19 @@ class TestNormalizeOptionalTagKey:assert normalize_optional_tag_key("skyvern") == "skyvern"+class TestNormalizeOptionalSystemTagKey:+ def test_reserved_key_shape_is_valid_for_system_writers(self) -> None:+ assert normalize_optional_system_tag_key(" skyvern.platform ") == "skyvern.platform"++ def test_non_reserved_key_rejected(self) -> None:+ with pytest.raises(ValueError, match="reserved"):+ normalize_optional_system_tag_key("env")++ def test_bad_shape_still_rejected(self) -> None:+ with pytest.raises(ValueError, match="must match"):+ normalize_optional_system_tag_key("skyvern bad")++class TestNormalizeTagValue:def test_strips_whitespace(self) -> None:assert normalize_tag_value(" prod ") == "prod"diff --git a/tests/unit/test_tags_repository.py b/tests/unit/test_tags_repository.pyindex 56efc07a6..6f56c8a7c 100644--- a/tests/unit/test_tags_repository.py+++ b/tests/unit/test_tags_repository.py@@ -21,6 +21,8 @@ from skyvern.forge.sdk.db.models import (WorkflowTagEventModel,)from skyvern.forge.sdk.db.repositories.tags import (+ MAX_SYSTEM_TAGS_PER_RUN,+ MAX_TAGS_PER_RUN,MAX_TAGS_PER_WORKFLOW,RunTagWorkflowRunMismatch,TagCountLimitExceeded,@@ -243,6 +245,20 @@ async def test_attribution_carries_caller_and_source(repo: TagsRepository) -> Noassert history[0].caller_type == CallerType.API_KEY.value+async def test_system_source_persists_on_workflow_tags(repo: TagsRepository) -> None:+ ctx = TagWriteContext(+ caller_id="system:foundation",+ source=TagSource.SYSTEM,+ caller_type=CallerType.SYSTEM,+ )+ await repo.apply_tag_changes(WPID, ORG_ID, sets={"team": "core"}, deletes=set(), context=ctx)++ history = await repo.get_tag_event_history(WPID, ORG_ID)+ assert history[0].source == TagSource.SYSTEM.value+ assert history[0].caller_type == CallerType.SYSTEM.value++@pytest.mark.asyncio@pytest.mark.parametrize("caller_type",@@ -493,6 +509,68 @@ async def test_apply_run_tag_changes_supports_standalone_labels_and_cap(repo: Taawait repo.apply_run_tag_changes(WRID, ORG_ID, sets={}, deletes=set(), context=_ctx(), label_sets=["over"])+async def test_apply_system_run_tag_changes_writes_reserved_tags_with_system_provenance(+ repo: TagsRepository,+) -> None:+ await _seed_workflow_run(repo, WRID)++ await repo.apply_system_run_tag_changes(+ workflow_run_id=WRID,+ organization_id=ORG_ID,+ sets={"skyvern.platform": "github"},+ caller_id="system:platform-detector",+ )++ current = await repo.get_active_grouped_tags_for_run(WRID, ORG_ID)+ assert current == {"skyvern.platform": "github"}+ history = await repo.get_run_tag_event_history(WRID, ORG_ID, key="skyvern.platform")+ assert history[0].source == TagSource.SYSTEM.value+ assert history[0].caller_type == CallerType.SYSTEM.value+ assert history[0].set_by == "system:platform-detector"+ assert await _registered_keys(repo) == ["skyvern.platform"]+++async def test_non_system_run_tag_writer_cannot_write_reserved_keys(repo: TagsRepository) -> None:+ await _seed_workflow_run(repo, WRID)++ with pytest.raises(ValueError, match="reserved"):+ await repo.apply_run_tag_changes(+ WRID,+ ORG_ID,+ sets={"skyvern.platform": "github"},+ deletes=set(),+ context=_ctx(),+ )+++async def test_system_run_tags_have_separate_cap_from_customer_tags(repo: TagsRepository) -> None:+ await _seed_workflow_run(repo, WRID)+ customer_tags = {f"k{i}": "v" for i in range(MAX_TAGS_PER_RUN)}+ system_tags = {f"skyvern.k{i}": "v" for i in range(MAX_SYSTEM_TAGS_PER_RUN)}++ await repo.apply_run_tag_changes(WRID, ORG_ID, sets=customer_tags, deletes=set(), context=_ctx())+ await repo.apply_system_run_tag_changes(+ workflow_run_id=WRID,+ organization_id=ORG_ID,+ sets=system_tags,+ caller_id="system:foundation",+ )++ rows = await repo.get_active_tag_events_for_run(WRID, ORG_ID)+ assert len(rows) == MAX_TAGS_PER_RUN + MAX_SYSTEM_TAGS_PER_RUN++ with pytest.raises(TagCountLimitExceeded):+ await repo.apply_system_run_tag_changes(+ workflow_run_id=WRID,+ organization_id=ORG_ID,+ sets={"skyvern.one_too_many": "v"},+ caller_id="system:foundation",+ )++@pytest.mark.asyncioasync def test_apply_run_tag_changes_rejects_run_from_other_org(repo: TagsRepository) -> None:await _seed_workflow_run(repo, WRID, org_id=ORG_ID)@@ -543,6 +621,10 @@ async def test_count_active_runs_per_key_and_value(repo: TagsRepository) -> Noneassert await repo.count_active_runs_per_key(ORG_ID) == {"env": 2, "team": 1}assert await repo.count_active_runs_per_value(ORG_ID) == {("env", "prod"): 2, ("team", "core"): 1}+ assert await repo.count_active_runs_for_key(ORG_ID, "env") == 2+ assert await repo.count_active_runs_for_key(ORG_ID, "team") == 1+ assert await repo.count_active_runs_for_value(ORG_ID, "env", "prod") == 2+ assert await repo.count_active_runs_for_value(ORG_ID, "env", "stg") == 0@pytest.mark.asyncio@@ -651,6 +733,20 @@ async def test_count_active_workflows_per_key(repo: TagsRepository) -> None:assert counts == {"env": 2, "team": 1}+async def test_count_active_workflows_for_key_targeted(repo: TagsRepository) -> None:+ await _seed_workflow(repo, "wpid_a")+ await _seed_workflow(repo, "wpid_b")+ await _seed_workflow(repo, "wpid_gone", deleted=True)+ await repo.apply_tag_changes("wpid_a", ORG_ID, sets={"env": "prod"}, deletes=set(), context=_ctx())+ await repo.apply_tag_changes("wpid_b", ORG_ID, sets={"env": "stg", "team": "core"}, deletes=set(), context=_ctx())+ await repo.apply_tag_changes("wpid_gone", ORG_ID, sets={"env": "dev"}, deletes=set(), context=_ctx())++ assert await repo.count_active_workflows_for_key(ORG_ID, "env") == 2+ assert await repo.count_active_workflows_for_key(ORG_ID, "team") == 1+ assert await repo.count_active_workflows_for_key(ORG_ID, "unknown") == 0++@pytest.mark.asyncioasync def test_count_active_workflows_per_key_ignores_deleted_tags(repo: TagsRepository) -> None:await repo.apply_tag_changes("wpid_a", ORG_ID, sets={"env": "prod"}, deletes=set(), context=_ctx())@@ -666,7 +762,10 @@ async def test_delete_tag_key_cascades_across_workflows(repo: TagsRepository) ->removed = await repo.delete_tag_key(ORG_ID, "env", _ctx())- assert removed == 2+ assert removed is not None+ assert removed.removed_from_workflow_count == 2+ assert removed.removed_from_run_count == 0+ assert removed.removed_count == 2# Tag gone from both workflows...assert await repo.get_active_grouped_tags_for_workflow("wpid_a", ORG_ID) == {}assert await repo.get_active_grouped_tags_for_workflow("wpid_b", ORG_ID) == {"team": "core"}@@ -683,9 +782,12 @@ async def test_delete_tag_key_cascades_across_workflow_runs(repo: TagsRepositoryawait repo.apply_run_tag_changes("wr_a", ORG_ID, sets={"env": "prod"}, deletes=set(), context=_ctx())await repo.apply_run_tag_changes("wr_b", ORG_ID, sets={"env": "stg", "team": "core"}, deletes=set(), context=_ctx())- removed_workflows = await repo.delete_tag_key(ORG_ID, "env", _ctx())+ removed = await repo.delete_tag_key(ORG_ID, "env", _ctx())- assert removed_workflows == 1+ assert removed is not None+ assert removed.removed_from_workflow_count == 1+ assert removed.removed_from_run_count == 2+ assert removed.removed_count == 3assert await repo.get_active_grouped_tags_for_workflow("wpid_a", ORG_ID) == {}assert await repo.get_active_grouped_tags_for_run("wr_a", ORG_ID) == {}assert await repo.get_active_grouped_tags_for_run("wr_b", ORG_ID) == {"team": "core"}@@ -706,7 +808,9 @@ async def test_delete_tag_key_unknown_returns_none(repo: TagsRepository) -> Noneasync def test_delete_tag_key_idempotent(repo: TagsRepository) -> None:await repo.apply_tag_changes("wpid_a", ORG_ID, sets={"env": "prod"}, deletes=set(), context=_ctx())- assert await repo.delete_tag_key(ORG_ID, "env", _ctx()) == 1+ removed = await repo.delete_tag_key(ORG_ID, "env", _ctx())+ assert removed is not None+ assert removed.removed_count == 1# Second call: key already soft-deleted, no active SETs left.assert await repo.delete_tag_key(ORG_ID, "env", _ctx()) is None@@ -930,6 +1034,21 @@ async def test_list_tag_values_returns_active_rows_ordered(repo: TagsRepository)assert [(v.key, v.value, v.color) for v in values] == [("env", "prod", "blue"), ("team", "core", "purple")]+async def test_list_tag_values_filters_by_key(repo: TagsRepository) -> None:+ await repo.apply_tag_changes(+ WPID,+ ORG_ID,+ sets={"env": "prod", "region": "us-west"},+ deletes=set(),+ context=_ctx(),+ colors={"env": "green", "region": "red"},+ )++ values = await repo.list_tag_values(ORG_ID, key="region")+ assert [(v.key, v.value, v.color) for v in values] == [("region", "us-west", "red")]++@pytest.mark.asyncioasync def test_list_tag_values_is_org_scoped(repo: TagsRepository) -> None:await repo.apply_tag_changes(@@ -1170,7 +1289,10 @@ async def test_delete_tag_value_cascades_and_counts(repo: TagsRepository) -> Nonremoved = await repo.delete_tag_value(ORG_ID, "env", "prod", _ctx())- assert removed == 2+ assert removed is not None+ assert removed.removed_from_workflow_count == 2+ assert removed.removed_from_run_count == 0+ assert removed.removed_count == 2assert await repo.get_active_grouped_tags_for_workflow("wpid_a", ORG_ID) == {}assert await repo.get_active_grouped_tags_for_workflow("wpid_b", ORG_ID) == {}# A sibling value under the same key is untouched.@@ -1187,9 +1309,12 @@ async def test_delete_tag_value_cascades_across_workflow_runs(repo: TagsRepositoawait repo.apply_run_tag_changes("wr_b", ORG_ID, sets={"env": "prod"}, deletes=set(), context=_ctx())await repo.apply_run_tag_changes("wr_c", ORG_ID, sets={"env": "stg"}, deletes=set(), context=_ctx())- removed_workflows = await repo.delete_tag_value(ORG_ID, "env", "prod", _ctx())+ removed = await repo.delete_tag_value(ORG_ID, "env", "prod", _ctx())- assert removed_workflows == 1+ assert removed is not None+ assert removed.removed_from_workflow_count == 1+ assert removed.removed_from_run_count == 2+ assert removed.removed_count == 3assert await repo.get_active_grouped_tags_for_workflow("wpid_a", ORG_ID) == {}assert await repo.get_active_grouped_tags_for_run("wr_a", ORG_ID) == {}assert await repo.get_active_grouped_tags_for_run("wr_b", ORG_ID) == {}@@ -1237,7 +1362,9 @@ async def test_delete_tag_value_unknown_returns_none(repo: TagsRepository) -> Noasync def test_delete_tag_value_idempotent(repo: TagsRepository) -> None:await repo.apply_tag_changes("wpid_a", ORG_ID, sets={"env": "prod"}, deletes=set(), context=_ctx())- assert await repo.delete_tag_value(ORG_ID, "env", "prod", _ctx()) == 1+ removed = await repo.delete_tag_value(ORG_ID, "env", "prod", _ctx())+ assert removed is not None+ assert removed.removed_count == 1# Second call: no active SET, no active color row left.assert await repo.delete_tag_value(ORG_ID, "env", "prod", _ctx()) is Nonediff --git a/tests/unit/test_workflow_run_parameter_batching.py b/tests/unit/test_workflow_run_parameter_batching.pyindex 501963c60..db877c6f2 100644--- a/tests/unit/test_workflow_run_parameter_batching.py+++ b/tests/unit/test_workflow_run_parameter_batching.py@@ -20,7 +20,8 @@ from skyvern.forge.sdk.core import skyvern_contextfrom skyvern.forge.sdk.core.skyvern_context import SkyvernContextfrom skyvern.forge.sdk.db.enums import WorkflowRunTriggerTypefrom skyvern.forge.sdk.workflow.models.parameter import WorkflowParameter, WorkflowParameterType-from skyvern.forge.sdk.workflow.models.workflow import WorkflowRequestBody+from skyvern.forge.sdk.workflow.models.tags import CallerType, TagSource, TagWriteContext+from skyvern.forge.sdk.workflow.models.workflow import WorkflowDefinition, WorkflowRequestBodyfrom skyvern.forge.sdk.workflow.service import WorkflowService@@ -68,6 +69,7 @@ def _make_service_with_mocks(code_version=None,adaptive_caching=False,sequential_key=None,+ workflow_definition=WorkflowDefinition(blocks=[], parameters=[]),)workflow_run = SimpleNamespace(workflow_run_id="wr_test", workflow_permanent_id="wpid_test")@@ -95,6 +97,167 @@ def reset_context() -> Generator[None]:skyvern_context.reset()+async def test_apply_initial_run_metadata_tags_uses_system_source_for_fallback_context() -> None:+ explicit_context = TagWriteContext(caller_id="user_test", source=TagSource.MANUAL, caller_type=CallerType.USER)++ with patch("skyvern.forge.sdk.workflow.service.app") as mock_app:+ mock_app.DATABASE.tags.apply_run_tag_changes = AsyncMock()++ await WorkflowService._apply_initial_run_metadata_tags(+ workflow_run_id="wr_x",+ organization_id="o_x",+ run_metadata={"env": "prod"},+ context=None,+ )++ fallback_context = mock_app.DATABASE.tags.apply_run_tag_changes.await_args.kwargs["context"]+ assert fallback_context.source == TagSource.SYSTEM+ assert fallback_context.caller_type == CallerType.SYSTEM++ await WorkflowService._apply_initial_run_metadata_tags(+ workflow_run_id="wr_x",+ organization_id="o_x",+ run_metadata={"env": "prod"},+ context=explicit_context,+ )++ assert mock_app.DATABASE.tags.apply_run_tag_changes.await_args_list[1].kwargs["context"] is explicit_context+ assert explicit_context.source == TagSource.MANUAL+++async def test_setup_workflow_run_writes_run_metadata_as_run_tags() -> None:+ service, organization, workflow_run = _make_service_with_mocks(workflow_parameters=[])+ request = WorkflowRequestBody(data={}, run_metadata={"env": "prod", "team": "growth"})+ tag_context = TagWriteContext(caller_id="user_test", source=TagSource.MANUAL, caller_type=CallerType.USER)++ with patch("skyvern.forge.sdk.workflow.service.app") as mock_app:+ mock_app.EXPERIMENTATION_PROVIDER.is_feature_enabled_cached = AsyncMock(return_value=False)+ mock_app.AGENT_FUNCTION.should_use_flex_llm_routing = AsyncMock(return_value=False)+ mock_app.DATABASE.tags.apply_run_tag_changes = AsyncMock()++ await service.setup_workflow_run(+ request_id="req_test",+ workflow_request=request,+ workflow_permanent_id="wpid_test",+ organization=organization,+ tag_write_context=tag_context,+ )++ mock_app.DATABASE.tags.apply_run_tag_changes.assert_awaited_once_with(+ workflow_run_id=workflow_run.workflow_run_id,+ organization_id=organization.organization_id,+ sets={"env": "prod", "team": "growth"},+ deletes=set(),+ context=tag_context,+ )+++async def test_setup_workflow_run_continues_when_initial_run_tag_write_fails() -> None:+ service, organization, workflow_run = _make_service_with_mocks(workflow_parameters=[])+ request = WorkflowRequestBody(data={}, run_metadata={"env": "prod"})++ with patch("skyvern.forge.sdk.workflow.service.app") as mock_app:+ mock_app.EXPERIMENTATION_PROVIDER.is_feature_enabled_cached = AsyncMock(return_value=False)+ mock_app.AGENT_FUNCTION.should_use_flex_llm_routing = AsyncMock(return_value=False)+ mock_app.DATABASE.tags.apply_run_tag_changes = AsyncMock(side_effect=RuntimeError("tag write failed"))++ result = await service.setup_workflow_run(+ request_id="req_test",+ workflow_request=request,+ workflow_permanent_id="wpid_test",+ organization=organization,+ )++ assert result is workflow_run+ mock_app.DATABASE.tags.apply_run_tag_changes.assert_awaited_once()+++async def test_setup_workflow_run_writes_detected_platform_as_system_run_tag() -> None:+ service, organization, workflow_run = _make_service_with_mocks(workflow_parameters=[])++ with (+ patch("skyvern.forge.sdk.workflow.service.app") as mock_app,+ patch(+ "skyvern.forge.sdk.workflow.service.workflow_script_service.detect_workflow_platform",+ return_value="known_platform",+ ) as detect_platform,+ ):+ mock_app.EXPERIMENTATION_PROVIDER.is_feature_enabled_cached = AsyncMock(return_value=False)+ mock_app.AGENT_FUNCTION.should_use_flex_llm_routing = AsyncMock(return_value=False)+ mock_app.DATABASE.tags.apply_system_run_tag_changes = AsyncMock()++ result = await service.setup_workflow_run(+ request_id="req_test",+ workflow_request=WorkflowRequestBody(data={}),+ workflow_permanent_id="wpid_test",+ organization=organization,+ )++ assert result is workflow_run+ detect_platform.assert_called_once_with(service.get_workflow_by_permanent_id.return_value, {})+ mock_app.DATABASE.tags.apply_system_run_tag_changes.assert_awaited_once_with(+ workflow_run_id=workflow_run.workflow_run_id,+ organization_id=organization.organization_id,+ sets={"skyvern.platform": "known_platform"},+ caller_id="system:platform-detector",+ )+++async def test_setup_workflow_run_skips_platform_tag_when_detection_has_no_verdict() -> None:+ service, organization, _ = _make_service_with_mocks(workflow_parameters=[])++ with (+ patch("skyvern.forge.sdk.workflow.service.app") as mock_app,+ patch(+ "skyvern.forge.sdk.workflow.service.workflow_script_service.detect_workflow_platform",+ return_value=None,+ ),+ ):+ mock_app.EXPERIMENTATION_PROVIDER.is_feature_enabled_cached = AsyncMock(return_value=False)+ mock_app.AGENT_FUNCTION.should_use_flex_llm_routing = AsyncMock(return_value=False)+ mock_app.DATABASE.tags.apply_system_run_tag_changes = AsyncMock()++ await service.setup_workflow_run(+ request_id="req_test",+ workflow_request=WorkflowRequestBody(data={}),+ workflow_permanent_id="wpid_test",+ organization=organization,+ )++ mock_app.DATABASE.tags.apply_system_run_tag_changes.assert_not_awaited()+++async def test_setup_workflow_run_continues_when_platform_tag_write_fails() -> None:+ service, organization, workflow_run = _make_service_with_mocks(workflow_parameters=[])++ with (+ patch("skyvern.forge.sdk.workflow.service.app") as mock_app,+ patch(+ "skyvern.forge.sdk.workflow.service.workflow_script_service.detect_workflow_platform",+ return_value="known_platform",+ ),+ ):+ mock_app.EXPERIMENTATION_PROVIDER.is_feature_enabled_cached = AsyncMock(return_value=False)+ mock_app.AGENT_FUNCTION.should_use_flex_llm_routing = AsyncMock(return_value=False)+ mock_app.DATABASE.tags.apply_system_run_tag_changes = AsyncMock(side_effect=RuntimeError("tag write failed"))++ result = await service.setup_workflow_run(+ request_id="req_test",+ workflow_request=WorkflowRequestBody(data={}),+ workflow_permanent_id="wpid_test",+ organization=organization,+ )++ assert result is workflow_run+ mock_app.DATABASE.tags.apply_system_run_tag_changes.assert_awaited_once()++@pytest.mark.asyncioasync def test_setup_workflow_run_raises_on_missing_required_parameters() -> None:"""When required parameters have no value and no default, setup should raise MissingValueForParameter."""diff --git a/tests/unit/test_workflow_script_cache_key_resolution.py b/tests/unit/test_workflow_script_cache_key_resolution.pyindex 34ea79bec..c3583d0fe 100644--- a/tests/unit/test_workflow_script_cache_key_resolution.py+++ b/tests/unit/test_workflow_script_cache_key_resolution.py@@ -6,7 +6,11 @@ from jinja2 import UndefinedErrorfrom skyvern.forge.sdk.workflow.models.workflow import Workflow, is_adaptive_caching_from_effective_statefrom skyvern.services import workflow_script_service-from skyvern.services.workflow_script_service import CacheKeyResolutionError, resolve_cache_key_value+from skyvern.services.workflow_script_service import (+ CacheKeyResolutionError,+ detect_workflow_platform,+ resolve_cache_key_value,+)def _workflow(cache_key: str | None = "default", url: str | None = "https://example.com/login") -> Workflow:@@ -66,6 +70,18 @@ def test_resolve_empty_cache_key_uses_platform_when_detected() -> None:assert resolve_cache_key_value(workflow, {}, adaptive_caching=False) == "known_platform"+def test_detect_workflow_platform_uses_first_resolved_block_domain() -> None:+ workflow = _workflow(cache_key="custom", url="https://ats.example.com/login")++ assert detect_workflow_platform(workflow, {}) == "known_platform"+++def test_detect_workflow_platform_returns_none_when_detector_has_no_verdict() -> None:+ workflow = _workflow(cache_key="custom", url="https://essentials.example.com/login")++ assert detect_workflow_platform(workflow, {}) is None++def test_resolve_appends_v2_when_adaptive_caching_enabled() -> None:workflow = _workflow(cache_key="custom", url=None)