Skip to content

Automate browser based workflows with AI

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.json
index 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.tsx
new file mode 100644
index 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.tsx
new file mode 100644
index 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.tsx
index 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 */}
<ApiWebhookActionsMenu
getOptions={() => {
diff --git a/skyvern-frontend/src/routes/tasks/hooks/useRunTagMutations.test.tsx b/skyvern-frontend/src/routes/tasks/hooks/useRunTagMutations.test.tsx
index 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.ts
index 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.tsx
index 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.tsx
new file mode 100644
index 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.tsx
index 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}>
<TableCell
className="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>
<TableCell
className="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.tsx
index 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.tsx
index 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.tsx
index 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.tsx
index 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.tsx
index 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) ? (
<button
type="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.tsx
index 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.tsx
index 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.tsx
index 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.ts
index 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.py
index 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.py
index 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 annotations
from dataclasses import dataclass
from datetime import datetime, timezone
+from typing import Any
import structlog
from 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_KEYS
MAX_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_deletes
projected_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 key
then value. The frontend joins these onto tags by (key, value) the same way
it 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 that
currently 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 not
registered (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 = now
await 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 the
value, 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 a
registered 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.py
index 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, Protocol
from sqlalchemy import and_, select
from sqlalchemy.sql.elements import ColumnElement
-from skyvern.forge.sdk.db.models import WorkflowTagEventModel
+from skyvern.forge.sdk.db.models import WorkflowRunTagEventModel, WorkflowTagEventModel
from 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 filters
def _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.py
index 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_par
from skyvern.forge.sdk.core.permissions.permission_checker_factory import PermissionCheckerFactory
from skyvern.forge.sdk.core.security import generate_skyvern_signature
from 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_features
from skyvern.forge.sdk.executor.factory import AsyncExecutorFactory
from 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_key
from 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.organization
await 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_id
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)
# 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_WPIDS
def _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 sorted
standalone-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.organization
original_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 = None
try:
- 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 internally
workflow_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.organization
context = skyvern_context.ensure_context()
request_id = context.request_id
await 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 e
diff --git a/skyvern/forge/sdk/workflow/models/tags.py b/skyvern/forge/sdk/workflow/models/tags.py
index 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 datetime
from enum import StrEnum
@@ -10,6 +11,7 @@ class TagSource(StrEnum):
BACKFILL = "backfill" # written by a one-off migration/script over existing rows
INHERITED = "inherited" # copied from a parent (e.g. folder) rather than set directly
IMPORT = "import" # ingested from an external system
+ SYSTEM = "system" # written by Skyvern-owned automation, not a public caller
class 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: str
source: TagSource
caller_type: CallerType | None = None
+ set_at: datetime | None = None
diff --git a/skyvern/forge/sdk/workflow/models/validators.py b/skyvern/forge/sdk/workflow/models/validators.py
index 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 None
if 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 trimmed
diff --git a/skyvern/forge/sdk/workflow/service.py b/skyvern/forge/sdk/workflow/service.py
index 71b9b026c..5e2512174 100644
--- a/skyvern/forge/sdk/workflow/service.py
+++ b/skyvern/forge/sdk/workflow/service.py
@@ -3,6 +3,7 @@ import copy
import importlib.util
import json
import os
+import random
import textwrap
import time
import 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, TagWriteContext
from 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 = 120
MANAGED_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,
+ )
+
@staticmethod
def _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.py
index 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.py
index 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_valida
from 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: str
removed_from_workflow_count: int
+ removed_from_run_count: int = 0
+ removed_count: int = 0
class TagKeyUpdate(BaseModel):
@@ -311,6 +318,8 @@ class TagValueDeleteResponse(BaseModel):
key: str
value: str
removed_from_workflow_count: int
+ removed_from_run_count: int = 0
+ removed_count: int = 0
class 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 null
for 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.py
index 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.py
index 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 WorkflowRunTriggerType
from skyvern.forge.sdk.executor.factory import AsyncExecutorFactory
from skyvern.forge.sdk.schemas.organizations import Organization
from skyvern.forge.sdk.workflow.exceptions import InvalidTemplateWorkflowPermanentId
+from skyvern.forge.sdk.workflow.models.tags import TagWriteContext
from skyvern.forge.sdk.workflow.models.workflow import WorkflowRequestBody, WorkflowRun
from 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.py
index 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, HTTPException
from skyvern.exceptions import WorkflowNotFound
from skyvern.forge.sdk.db.enums import WorkflowRunTriggerType
from skyvern.forge.sdk.routes import agent_protocol
+from skyvern.forge.sdk.workflow.models.tags import CallerType, TagSource
from skyvern.forge.sdk.workflow.models.workflow import WorkflowRequestBody, WorkflowRunStatus
from 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.asyncio
async 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: p
return_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: p
monkeypatch.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: p
run_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: p
workflow_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: p
mock_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: p
assert call_kwargs["request_id"] == "req_123"
assert call_kwargs["trigger_type"] == WorkflowRunTriggerType.manual
assert 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.USER
assert 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.M
request=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(monkeypatch
get_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(monkeypatch
request=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(monkeypatch
assert run_workflow_mock.call_args.kwargs["version"] == 3
assert run_workflow_mock.call_args.kwargs["ignore_inherited_workflow_system_prompt"] is False
assert 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.M
request=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.MonkeyP
request=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.py
new file mode 100644
index 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.py
index 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 IntegrityError
from sqlalchemy.ext.asyncio import AsyncEngine, async_sessionmaker, create_async_engine
from 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, WorkflowRunModel
from skyvern.forge.sdk.db.repositories.tags import TagsRepository
from skyvern.forge.sdk.schemas.organizations import Organization
from 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 eng
await eng.dispose()
@@ -117,9 +137,38 @@ def app_with_routes(repo: TagsRepository, monkeypatch: pytest.MonkeyPatch) -> Fa
workflows_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 = repo
database_mock.workflows = workflows_mock
+ database_mock.workflow_runs = workflow_runs_mock
app_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 == 200
assert 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.text
assert 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.py
index 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.py
index 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) -> No
assert 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: Ta
await 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.asyncio
async 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) -> None
assert 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.asyncio
async 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: TagsRepository
await 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 == 3
assert 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) -> None
async 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.asyncio
async 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) -> Non
removed = 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 == 2
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) == {}
# A sibling value under the same key is untouched.
@@ -1187,9 +1309,12 @@ async def test_delete_tag_value_cascades_across_workflow_runs(repo: TagsReposito
await 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 == 3
assert 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) -> No
async 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 None
diff --git a/tests/unit/test_workflow_run_parameter_batching.py b/tests/unit/test_workflow_run_parameter_batching.py
index 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_context
from skyvern.forge.sdk.core.skyvern_context import SkyvernContext
from skyvern.forge.sdk.db.enums import WorkflowRunTriggerType
from 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, WorkflowRequestBody
from 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.asyncio
async 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.py
index 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 UndefinedError
from skyvern.forge.sdk.workflow.models.workflow import Workflow, is_adaptive_caching_from_effective_state
from 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)