FE-2006: Identify flow definitions by their EntityId not just EntityUuid

apps/hash-ai-worker-ts/scripts/flow-scenarios/run-flow-scenario.ts

@@ -294,7 +294,7 @@ const getUserFlowDefinitionId = (
 ) => uuidv5(userId, scenarioFlowDefinitionId) as EntityUuid;
 
 /**
- * Runs load their definition from the `Flow Definition` entity whose uuid is the definition's id. Migrations only
+ * Runs load their definition from its `Flow Definition` entity, in the user's web here. Migrations only
  * seed the flows HASH provides, so the scenario's definition is written to the user's web: created if it doesn't
  * exist, and updated if it differs, like `seedFlowDefinitions` does for seeded flows.
  */
@@ -318,7 +318,10 @@ const ensureFlowDefinitionEntity = async ({
   const properties = mapFlowDefinitionToEntityProperties(flowDefinition);
 
   const existingEntity = await getFlowDefinitionEntityById({
-    flowDefinitionId,
+    flowDefinitionEntityId: entityIdFromComponents(
+      userId as WebId,
+      flowDefinitionId,
+    ),
     graphApiClient: graphApi,
     userAuthentication: authentication,
   });
@@ -446,6 +449,10 @@ const startRun = async ({
 }) => {
   const workflowId = generateUuid() as EntityUuid;
   const webId = userId as WebId;
+  const flowDefinitionEntityId = entityIdFromComponents(
+    webId,
+    flow.flowDefinitionId,
+  );
   const params: RunFlowWorkflowParams = {
     ...(taskQueue === "ai"
       ? {
@@ -460,7 +467,7 @@ const startRun = async ({
       : {}),
     flowRunEntityUuid: workflowId,
     flowInputs: inputs,
-    flowDefinitionId: flow.flowDefinitionId,
+    flowDefinitionEntityId,
     userAuthentication: { actorId: userId },
     webId,
   };
@@ -469,7 +476,7 @@ const startRun = async ({
     taskQueue,
     args: [params],
     memo: {
-      flowDefinitionId: flow.flowDefinitionId,
+      flowDefinitionEntityId,
       userAccountId: userId,
       webId,
     },
@@ -902,7 +909,10 @@ const main = async () => {
     const workflowError = await workflowErrorWhenClosed;
 
     const flowRun = await getFlowRunFromTemporalWorkflowId({
-      flowDefinitionId,
+      flowDefinitionEntityId: entityIdFromComponents(
+        userId as WebId,
+        flowDefinitionId,
+      ),
       flowRunEntityId: entityIdFromComponents(userId as WebId, workflowId),
       name: flowDefinition.name,
       temporalClient: client,

apps/hash-ai-worker-ts/src/activities/flow-activities/generate-flow-run-name-activity.ts

@@ -1,6 +1,7 @@
 import {
   flowDefinitionIds,
-  isGoalFlowDefinitionId,
+  isGoalFlowDefinitionEntityId,
+  isHashFlowDefinitionEntityId,
 } from "@local/hash-isomorphic-utils/flows/flow-definition-ids";
 
 import { getFlowContext } from "../shared/get-flow-context.js";
@@ -9,7 +10,7 @@ import { getTextContentFromLlmMessage } from "../shared/get-llm-response/llm-mes
 import { graphApiClient } from "../shared/graph-api-client.js";
 
 import type { UsageTrackingParams } from "../shared/get-llm-response.js";
-import type { EntityUuid } from "@blockprotocol/type-system";
+import type { EntityId, EntityUuid } from "@blockprotocol/type-system";
 import type {
   AutomaticInferenceInputName,
   ManualInferenceInputName,
@@ -25,7 +26,7 @@ import type {
 
 type GenerateFlowRunNameActivityParams = {
   flowDefinition: FlowDefinition<FlowActionDefinitionId>;
-  flowDefinitionId: EntityUuid;
+  flowDefinitionEntityId: EntityId;
   flowInputs: FlowInputValues;
 };
 
@@ -95,13 +96,14 @@ const inputKindsToIgnore: PayloadKind[] = [
 export const generateFlowRunName = async (
   params: GenerateFlowRunNameActivityParams,
 ) => {
-  const { flowDefinition, flowDefinitionId, flowInputs } = params;
+  const { flowDefinition, flowDefinitionEntityId, flowInputs } = params;
+
+  const isHashFlow = (flowDefinitionId: EntityUuid) =>
+    isHashFlowDefinitionEntityId(flowDefinitionEntityId, flowDefinitionId);
 
   if (
-    [
-      flowDefinitionIds.automaticBrowserInference,
-      flowDefinitionIds.manualBrowserInference,
-    ].includes(flowDefinitionId)
+    isHashFlow(flowDefinitionIds.automaticBrowserInference) ||
+    isHashFlow(flowDefinitionIds.manualBrowserInference)
   ) {
     const webPage = flowInputs[
       "visitedWebPage" satisfies AutomaticInferenceInputName &
@@ -113,7 +115,7 @@ export const generateFlowRunName = async (
     }
 
     return `${
-      flowDefinitionId === flowDefinitionIds.automaticBrowserInference
+      isHashFlow(flowDefinitionIds.automaticBrowserInference)
         ? "Auto-analyze"
         : "Analyze"
     } webpage: ${webPage.url}`;
@@ -130,7 +132,7 @@ export const generateFlowRunName = async (
     webId,
   };
 
-  if (isGoalFlowDefinitionId(flowDefinitionId)) {
+  if (isGoalFlowDefinitionEntityId(flowDefinitionEntityId)) {
     const researchBrief = flowInputs[
       "researchGuidance" satisfies GoalFlowInputName
     ]?.value as PayloadKindValues["Text"] | undefined;

apps/hash-ai-worker-ts/src/shared/testing-utilities/mock-get-flow-context.ts

@@ -1,6 +1,7 @@
 // eslint-disable-next-line import/no-extraneous-dependencies
 import { vi } from "vitest";
 
+import { entityIdFromComponents } from "@blockprotocol/type-system";
 import { HashEntity } from "@local/hash-graph-sdk/entity";
 import { mapFlowRunToEntityProperties } from "@local/hash-isomorphic-utils/flows/mappings";
 import { generateUuid } from "@local/hash-isomorphic-utils/generate-uuid";
@@ -34,7 +35,10 @@ const createDummyFlow = async (params: { actorId: ActorEntityUuid }) => {
   const dummyFlowRunProperties = mapFlowRunToEntityProperties({
     name: "dummy-name",
     flowInputs: {},
-    flowDefinitionId: generateUuid() as EntityUuid,
+    flowDefinitionEntityId: entityIdFromComponents(
+      actorId as WebId,
+      generateUuid() as EntityUuid,
+    ),
     steps: [],
     temporalWorkflowId: generateUuid(),
   });
@@ -132,7 +136,10 @@ vi.mock("@local/hash-backend-utils/temporal", async (importOriginal) => {
                   },
                 },
               },
-              flowDefinitionId: generateUuid() as EntityUuid,
+              flowDefinitionEntityId: entityIdFromComponents(
+                aliceUserAccountId as WebId,
+                generateUuid() as EntityUuid,
+              ),
               flowInputs: {},
               webId: aliceUserAccountId,
               userAuthentication: {

apps/hash-ai-worker-ts/src/workflows/run-flow-workflow.ts

@@ -10,7 +10,7 @@ import { heartbeatTimeoutSeconds } from "../shared/heartbeats.js";
 import { setQueryAndSignalHandlers } from "./run-flow-workflow/set-query-and-signal-handlers.js";
 
 import type { createFlowActivities } from "../activities/flow-activities.js";
-import type { EntityUuid } from "@blockprotocol/type-system";
+import type { EntityId } from "@blockprotocol/type-system";
 import type { ProxyFlowActivity } from "@local/hash-backend-utils/flows";
 import type {
   RunAiFlowWorkflowParams,
@@ -84,7 +84,7 @@ const proxyFlowActivity: ProxyFlowActivity<
 
 const generateFlowRunName = (params: {
   flowDefinition: FlowDefinition;
-  flowDefinitionId: EntityUuid;
+  flowDefinitionEntityId: EntityId;
   flowInputs: FlowInputValues;
 }) => {
   const { generateFlowRunName: generateFlowRunNameActivity } = proxyActivities<

apps/hash-api/src/ai/infer-entities-websocket/handle-infer-entities-request.ts

@@ -1,5 +1,9 @@
 import { getFlowRuns } from "@local/hash-backend-utils/flows";
-import { flowDefinitionIds } from "@local/hash-isomorphic-utils/flows/flow-definition-ids";
+import { getHashWebId } from "@local/hash-backend-utils/flows/shared/get-hash-web-id";
+import {
+  flowDefinitionIds,
+  generateHashFlowDefinitionEntityId,
+} from "@local/hash-isomorphic-utils/flows/flow-definition-ids";
 
 import { FlowRunStatus } from "../../graphql/api-types.gen";
 
@@ -41,20 +45,28 @@ export const handleInferEntitiesRequest = async ({
     payload: { webId, ...flowInputs },
   } = message;
 
-  const flowDefinitionId =
+  const hashWebId = await getHashWebId(graphApiClient, {
+    actorId: user.accountId,
+  });
+
+  const flowDefinitionEntityId = generateHashFlowDefinitionEntityId(
+    hashWebId,
     message.type === "manual-inference-request"
       ? flowDefinitionIds.manualBrowserInference
-      : flowDefinitionIds.automaticBrowserInference;
+      : flowDefinitionIds.automaticBrowserInference,
+  );
 
   if (message.type === "automatic-inference-request") {
     const openFlowRuns = await getFlowRuns({
       authentication: { actorId: user.accountId },
       filters: {
         executionStatus: FlowRunStatus.Running,
-        flowDefinitionIds: [
+        flowDefinitionEntityIds: [
           flowDefinitionIds.automaticBrowserInference,
           flowDefinitionIds.manualBrowserInference,
-        ],
+        ].map((flowDefinitionId) =>
+          generateHashFlowDefinitionEntityId(hashWebId, flowDefinitionId),
+        ),
       },
       graphApiClient,
       includeDetails: true,
@@ -91,7 +103,7 @@ export const handleInferEntitiesRequest = async ({
             },
           },
         },
-        flowDefinitionId,
+        flowDefinitionEntityId,
         flowInputs,
         /* So that the run's entity id can be worked out from the request, as the browser plugin does. */
         flowRunEntityUuid: requestUuid as EntityUuid,
@@ -100,7 +112,7 @@ export const handleInferEntitiesRequest = async ({
       },
     ],
     memo: {
-      flowDefinitionId,
+      flowDefinitionEntityId,
       userAccountId: user.accountId,
       webId,
     },

apps/hash-api/src/graph/knowledge/system-types/flow-schedule.ts

@@ -39,10 +39,7 @@ const isEntityFlowScheduleEntity = (
   );
 
 export const createFlowSchedule: ImpureGraphFunction<
-  CreateFlowScheduleInput & {
-    /** The `Flow Definition` entity the schedule starts runs of. */
-    flowDefinitionEntityId: EntityId;
-  },
+  CreateFlowScheduleInput,
   Promise<HashEntity<FlowSchedule>>
 > = async (context, authentication, params) => {
   const {

apps/hash-api/src/graphql/resolvers/flows/flow-schedule.ts

@@ -43,11 +43,11 @@ export const createFlowScheduleResolver: ResolverFn<
   const context = graphQLContextToImpureGraphContext(graphQLContext);
   const { authentication } = graphQLContext;
 
-  const { flowDefinitionId } = input;
+  const { flowDefinitionEntityId } = input;
 
-  const { flowDefinitionEntity, flowType } = await getRunnableFlowDefinition(
+  const { flowType } = await getRunnableFlowDefinition(
     graphQLContext,
-    flowDefinitionId,
+    flowDefinitionEntityId,
   );
 
   if (flowType === "ai" && !input.dataSources) {
@@ -56,10 +56,11 @@ export const createFlowScheduleResolver: ResolverFn<
 
   assertClientFlowInputs(input.flowInputs);
 
-  const schedule = await createFlowScheduleEntity(context, authentication, {
-    ...input,
-    flowDefinitionEntityId: flowDefinitionEntity.metadata.recordId.entityId,
-  });
+  const schedule = await createFlowScheduleEntity(
+    context,
+    authentication,
+    input,
+  );
 
   const props = simplifyProperties(schedule.properties);
   const scheduleId = extractEntityUuidFromEntityId(
@@ -72,7 +73,7 @@ export const createFlowScheduleResolver: ResolverFn<
     ...(flowType === "ai" && input.dataSources
       ? { dataSources: input.dataSources }
       : {}),
-    flowDefinitionId,
+    flowDefinitionEntityId,
     flowRunName: input.name,
     flowInputs: input.flowInputs,
     flowTriggerEntityId: schedule.metadata.recordId.entityId,
@@ -90,7 +91,7 @@ export const createFlowScheduleResolver: ResolverFn<
         taskQueue,
         args: [workflowParams],
         memo: {
-          flowDefinitionId,
+          flowDefinitionEntityId,
           userAccountId: user.accountId,
           webId: input.webId,
         },

apps/hash-api/src/graphql/resolvers/flows/get-flow-runs.ts

@@ -24,12 +24,12 @@ export const getFlowRunsResolver: ResolverFn<
 
   const { authentication, dataSources, temporal } = context;
 
-  const { flowDefinitionIds, executionStatus, cursor, limit } = args;
+  const { flowDefinitionEntityIds, executionStatus, cursor, limit } = args;
 
   return await getFlowRuns({
     authentication,
     filters: {
-      flowDefinitionIds,
+      flowDefinitionEntityIds,
       executionStatus,
       cursor,
       limit,

apps/hash-api/src/graphql/resolvers/flows/shared/get-runnable-flow-definition.ts

@@ -5,7 +5,7 @@ import { getFlowDefinitionFromEntity } from "@local/hash-isomorphic-utils/flows/
 import * as GraphQLError from "../../../error";
 
 import type { LoggedInGraphQLContext } from "../../../context";
-import type { EntityUuid } from "@blockprotocol/type-system";
+import type { EntityId } from "@blockprotocol/type-system";
 
 /**
  * Loads a flow's definition from its `Flow Definition` entity, and checks that the user can run it.
@@ -15,19 +15,19 @@ import type { EntityUuid } from "@blockprotocol/type-system";
  */
 export const getRunnableFlowDefinition = async (
   graphQLContext: LoggedInGraphQLContext,
-  flowDefinitionId: EntityUuid,
+  flowDefinitionEntityId: EntityId,
 ) => {
   const { dataSources, authentication, user } = graphQLContext;
 
   const flowDefinitionEntity = await getFlowDefinitionEntityById({
-    flowDefinitionId,
+    flowDefinitionEntityId,
     graphApiClient: dataSources.graphApi,
     userAuthentication: authentication,
   });
 
   if (!flowDefinitionEntity) {
     throw GraphQLError.notFound(
-      `No flow definition with id ${flowDefinitionId} exists, or you can't view it`,
+      `No flow definition with id ${flowDefinitionEntityId} exists, or you can't view it`,
     );
   }
 
@@ -38,7 +38,7 @@ export const getRunnableFlowDefinition = async (
   } catch (error) {
     /* The definition is stored data, so an invalid one is a fault here, not in the request. */
     throw GraphQLError.internal(
-      `Flow definition ${flowDefinitionId} is invalid: ${(error as Error).message}`,
+      `Flow definition ${flowDefinitionEntityId} is invalid: ${(error as Error).message}`,
     );
   }
 

apps/hash-api/src/graphql/resolvers/flows/start-flow.ts

@@ -23,7 +23,7 @@ export const startFlow: ResolverFn<
   MutationStartFlowArgs
 > = async (
   _,
-  { dataSources, flowInputs, flowDefinitionId, webId },
+  { dataSources, flowInputs, flowDefinitionEntityId, webId },
   graphQLContext,
 ) => {
   const { temporal, user } = graphQLContext;
@@ -33,7 +33,7 @@ export const startFlow: ResolverFn<
    */
   const { flowType } = await getRunnableFlowDefinition(
     graphQLContext,
-    flowDefinitionId,
+    flowDefinitionEntityId,
   );
 
   assertClientFlowInputs(flowInputs);
@@ -48,7 +48,7 @@ export const startFlow: ResolverFn<
     ...(flowType === "ai" ? { dataSources } : {}),
     flowRunEntityUuid: workflowId,
     flowInputs,
-    flowDefinitionId,
+    flowDefinitionEntityId,
     userAuthentication: { actorId: user.accountId },
     webId,
   };
@@ -59,7 +59,7 @@ export const startFlow: ResolverFn<
     taskQueue: flowType,
     args: [params],
     memo: {
-      flowDefinitionId,
+      flowDefinitionEntityId,
       userAccountId: user.accountId,
       webId,
     },

apps/hash-api/src/graphql/resolvers/knowledge/file/create-file-from-url.ts

@@ -44,6 +44,7 @@ export const createFileFromUrl: ResolverFn<
   if (user.enabledFeatureFlags.includes("ai")) {
     await triggerPdfAnalysisWorkflow({
       entity,
+      graphApiClient: context.graphApi,
       temporalClient: temporal,
       userAccountId: user.accountId,
       webId: extractWebIdFromEntityId(entity.entityId),